include rna parent class names in renaming list
authorCampbell Barton <ideasman42@gmail.com>
Tue, 10 Aug 2010 06:27:29 +0000 (06:27 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 10 Aug 2010 06:27:29 +0000 (06:27 +0000)
release/scripts/modules/rna_info.py
source/blender/makesrna/rna_cleanup/rna_cleaner_merge.py
source/blender/makesrna/rna_cleanup/rna_properties.txt

index 71895a25446b8c8d95619193b48f85a1c18a1a83..5d769d016413f0cfb95eac6bed9a917770be25fc 100644 (file)
@@ -625,18 +625,23 @@ def BuildRNAInfo():
 if __name__ == "__main__":
     import rna_info
     struct = rna_info.BuildRNAInfo()[0]
-    data = ""
+    data = []
     for struct_id, v in sorted(struct.items()):
-        struct_id_str = "".join(sid for sid in struct_id if struct_id)
-        props = [(prop.identifier, prop) for prop in v.properties]
+        struct_id_str = v.identifier # "".join(sid for sid in struct_id if struct_id)
+
+        for base in v.get_bases():
+            struct_id_str = base.identifier + "|" + struct_id_str
         
+        props = [(prop.identifier, prop) for prop in v.properties]
         for prop_id, prop in sorted(props):
             # if prop.type == 'boolean':
             #     continue
-            data += "%s.%s -> %s:    %s%s    %s\n" % (struct_id_str, prop.identifier, prop.identifier, prop.type, ", (read-only)" if prop.is_readonly else "", prop.description)
+            data.append("%s.%s -> %s:    %s%s    %s" % (struct_id_str, prop.identifier, prop.identifier, prop.type, ", (read-only)" if prop.is_readonly else "", prop.description))
+        data.sort()
 
     if bpy.app.background:
-        print(data)
+        import sys
+        sys.stderr.write("\n".join(data))
     else:
         text = bpy.data.texts.new(name="api.py")
         text.from_string(data)
index 9fcaa8be3f82d0c54136bab4a32f48315fd6dcf4..90b8f021d01fc80b6190d7a8a214dba055fb626d 100755 (executable)
@@ -9,7 +9,7 @@ Example usage:
 def main():
        
        def work_line_id(line):
-               return line[2], line[3] # class/from
+               return line[2].split("|")[-1], line[3] # class/from
        
        
        if not (sys.argv[-1].endswith(".py") and sys.argv[-2].endswith(".py")):
@@ -31,6 +31,12 @@ def main():
                except:
                        # print("not found", key)
                        val = val_orig
+                       
+               # always take the class from the base
+               val = list(val)
+               val[2] = val_orig[2]
+               print(val_orig[2])
+               val = tuple(val)
 
                rna_api_new.append(val)
        
@@ -53,4 +59,4 @@ def main():
                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
+       main()
index 7be224c751627865cacf8f06a2641ab003a65bfa..1d68aa0b66919f9968c466915f9442921f19e30e 100644 (file)
@@ -1,24 +1,4 @@
 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 -> frame_blend_in:   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 -> play_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'"
@@ -29,7 +9,169 @@ NOTE * CLASS.FROM -> TO:   TYPE  DESCRIPTION
 + * 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'"
++ * Actuator|ActionActuator.action -> action:   pointer  "'NO DESCRIPTION'"
++ * Actuator|ActionActuator.blendin -> frame_blend_in:   int  "'Number of frames of motion blending'"
++ * Actuator|ActionActuator.continue_last_frame -> use_continue_last_frame:   boolean  "'Restore last frame when switching on/off, otherwise play from the start each time'"
++ * Actuator|ActionActuator.frame_end -> frame_end:   int  "'NO DESCRIPTION'"
++ * Actuator|ActionActuator.frame_property -> frame_property:   string  '"Assign the action\'s current frame number to this property"'
++ * Actuator|ActionActuator.frame_start -> frame_start:   int  "'NO DESCRIPTION'"
++ * Actuator|ActionActuator.mode -> play_mode:   enum  "'Action playback type'"
++ * Actuator|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'"
++ * Actuator|ActionActuator.property -> property:   string  "'Use this property to define the Action position'"
++ * Actuator|ArmatureActuator.bone -> bone:   string  "'Bone on which the constraint is defined'"
++ * Actuator|ArmatureActuator.constraint -> constraint:   string  "'Name of the constraint you want to control'"
++ * Actuator|ArmatureActuator.mode -> mode:   enum  "'NO DESCRIPTION'"
++ * Actuator|ArmatureActuator.secondary_target -> secondary_target:   pointer  "'Set weight of this constraint'"
++ * Actuator|ArmatureActuator.target -> target:   pointer  "'Set this object as the target of the constraint'"
++ * Actuator|ArmatureActuator.weight -> weight:   float  "'Set weight of this constraint'"
++ * Actuator|CameraActuator.axis -> axis:   enum  "'Specify the axis the Camera will try to get behind'"
++ * Actuator|CameraActuator.height -> height:   float  "'NO DESCRIPTION'"
++ * Actuator|CameraActuator.max -> max:   float  "'NO DESCRIPTION'"
++ * Actuator|CameraActuator.min -> min:   float  "'NO DESCRIPTION'"
++ * Actuator|CameraActuator.object -> object:   pointer  "'Look at this Object'"
+Actuator|ConstraintActuator.damping -> damping:   int  "'Damping factor: time constant (in frame) of low pass filter'"
+Actuator|ConstraintActuator.damping_rotation -> damping_rotation:   int  "'Use a different damping for orientation'"
+Actuator|ConstraintActuator.detect_material -> use_material_detect:   boolean  "'Detect material instead of property'"
+Actuator|ConstraintActuator.direction -> direction:   enum  "'Set the direction of the ray'"
+Actuator|ConstraintActuator.direction_axis -> direction_axis:   enum  "'Select the axis to be aligned along the reference direction'"
+Actuator|ConstraintActuator.distance -> distance:   float  "'Set the maximum length of ray'"
+Actuator|ConstraintActuator.fh_damping -> fh_damping:   float  "'Damping factor of the Fh spring force'"
+Actuator|ConstraintActuator.fh_height -> fh_height:   float  "'Height of the Fh area'"
+Actuator|ConstraintActuator.fh_normal -> use_fh_normal:   boolean  "'Add a horizontal spring force on slopes'"
+Actuator|ConstraintActuator.fh_paralel_axis -> use_fh_paralel_axis:   boolean  "'Keep object axis parallel to normal'"
+Actuator|ConstraintActuator.force_distance -> use_force_distance:   boolean  "'Force distance of object to point of impact of ray'"
+Actuator|ConstraintActuator.limit -> limit:   enum  "'NO DESCRIPTION'"
+Actuator|ConstraintActuator.limit_max -> limit_max:   float  "'NO DESCRIPTION'"
+Actuator|ConstraintActuator.limit_min -> limit_min:   float  "'NO DESCRIPTION'"
+Actuator|ConstraintActuator.local -> use_local:   boolean  '"Set ray along object\'s axis or global axis"'
+Actuator|ConstraintActuator.material -> material:   string  "'Ray detects only Objects with this material'"
+Actuator|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'"
+Actuator|ConstraintActuator.max_rotation -> rotation_max:   float  "'Reference Direction'"
+Actuator|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'"
+Actuator|ConstraintActuator.mode -> mode:   enum  "'The type of the constraint'"
+Actuator|ConstraintActuator.normal -> use_normal:   boolean  "'Set object axis along (local axis) or parallel (global axis) to the normal at hit position'"
+Actuator|ConstraintActuator.persistent -> use_persistent:   boolean  "'Persistent actuator: stays active even if ray does not reach target'"
+Actuator|ConstraintActuator.property -> property:   string  "'Ray detect only Objects with this property'"
+Actuator|ConstraintActuator.range -> range:   float  "'Set the maximum length of ray'"
+Actuator|ConstraintActuator.spring -> spring:   float  "'Spring force within the Fh area'"
+Actuator|ConstraintActuator.time -> time:   int  "'Maximum activation time in frame, 0 for unlimited'"
+Actuator|EditObjectActuator.angular_velocity -> angular_velocity:   float  "'Angular velocity upon creation'"
+Actuator|EditObjectActuator.dynamic_operation -> dynamic_operation:   enum  "'NO DESCRIPTION'"
+Actuator|EditObjectActuator.enable_3d_tracking -> use_3d_tracking:   boolean  "'Enable 3D tracking'"
+Actuator|EditObjectActuator.linear_velocity -> linear_velocity:   float  "'Velocity upon creation'"
+Actuator|EditObjectActuator.local_angular_velocity -> use_local_angular_velocity:   boolean  "'Apply the rotation locally'"
+Actuator|EditObjectActuator.local_linear_velocity -> use_local_linear_velocity:   boolean  "'Apply the transformation locally'"
+Actuator|EditObjectActuator.mass -> mass:   float  "'The mass of the object'"
+Actuator|EditObjectActuator.mesh -> mesh:   pointer  '"Replace the existing, when left blank \'Phys\' will remake the existing physics mesh"'
+Actuator|EditObjectActuator.mode -> mode:   enum  "'The mode of the actuator'"
+Actuator|EditObjectActuator.object -> object:   pointer  "'Add this Object and all its children (cant be on an visible layer)'"
+Actuator|EditObjectActuator.replace_display_mesh -> use_replace_display_mesh:   boolean  "'Replace the display mesh'"
+Actuator|EditObjectActuator.replace_physics_mesh -> use_replace_physics_mesh:   boolean  "'Replace the physics mesh (triangle bounds only - compound shapes not supported)'"
+Actuator|EditObjectActuator.time -> time:   int  "'Duration the new Object lives or the track takes'"
+Actuator|EditObjectActuator.track_object -> track_object:   pointer  "'Track to this Object'"
+Actuator|FcurveActuator.add -> use_add:   boolean  "'F-Curve is added to the current loc/rot/scale in global or local coordinate according to Local flag'"
+Actuator|FcurveActuator.child -> apply_to_children:   boolean  "'Update F-Curve on all children Objects as well'"
+Actuator|FcurveActuator.force -> use_force:   boolean  "'Apply F-Curve as a global or local force depending on the local option (dynamic objects only)'"
+Actuator|FcurveActuator.frame_end -> frame_end:   int  "'NO DESCRIPTION'"
+Actuator|FcurveActuator.frame_property -> frame_property:   string  '"Assign the action\'s current frame number to this property"'
+Actuator|FcurveActuator.frame_start -> frame_start:   int  "'NO DESCRIPTION'"
+Actuator|FcurveActuator.local -> use_local:   boolean  "'Let the F-Curve act in local coordinates, used in Force and Add mode'"
+Actuator|FcurveActuator.play_type -> play_type:   enum  "'Specify the way you want to play the animation'"
+Actuator|FcurveActuator.property -> property:   string  "'Use this property to define the F-Curve position'"
+Actuator|Filter2DActuator.enable_motion_blur -> use_motion_blur:   boolean  "'Enable/Disable Motion Blur'"
+Actuator|Filter2DActuator.filter_pass -> filter_pass:   int  "'Set filter order'"
+Actuator|Filter2DActuator.glsl_shader -> glsl_shader:   pointer  "'NO DESCRIPTION'"
+Actuator|Filter2DActuator.mode -> mode:   enum  "'NO DESCRIPTION'"
+Actuator|Filter2DActuator.motion_blur_factor -> motion_blur_factor:   float  "'Set motion blur factor'"
+Actuator|GameActuator.filename -> filename:   string  'Load this blend file, use the "//" prefix for a path relative to the current blend file'
+Actuator|GameActuator.mode -> mode:   enum  "'NO DESCRIPTION'"
+Actuator|MessageActuator.body_message -> body_message:   string  "'Optional message body Text'"
+Actuator|MessageActuator.body_property -> body_property:   string  "'The message body will be set by the Property Value'"
+Actuator|MessageActuator.body_type -> body_type:   enum  "'Toggle message type: either Text or a PropertyName'"
+Actuator|MessageActuator.subject -> subject:   string  "'Optional message subject. This is what can be filtered on'"
+Actuator|MessageActuator.to_property -> to_property:   string  "'Optional send message to objects with this name only, or empty to broadcast'"
+Actuator|ObjectActuator.add_linear_velocity -> use_add_linear_velocity:   boolean  "'Toggles between ADD and SET linV'"
+Actuator|ObjectActuator.angular_velocity -> angular_velocity:   float  "'Sets the angular velocity'"
+Actuator|ObjectActuator.damping -> damping:   int  "'Number of frames to reach the target velocity'"
+Actuator|ObjectActuator.derivate_coefficient -> derivate_coefficient:   float  "'Not required, high values can cause instability'"
+Actuator|ObjectActuator.force -> force:   float  "'Sets the force'"
+Actuator|ObjectActuator.force_max_x -> force_max_x:   float  "'Set the upper limit for force'"
+Actuator|ObjectActuator.force_max_y -> force_max_y:   float  "'Set the upper limit for force'"
+Actuator|ObjectActuator.force_max_z -> force_max_z:   float  "'Set the upper limit for force'"
+Actuator|ObjectActuator.force_min_x -> force_min_x:   float  "'Set the lower limit for force'"
+Actuator|ObjectActuator.force_min_y -> force_min_y:   float  "'Set the lower limit for force'"
+Actuator|ObjectActuator.force_min_z -> force_min_z:   float  "'Set the lower limit for force'"
+Actuator|ObjectActuator.integral_coefficient -> integral_coefficient:   float  "'Low value (0.01) for slow response, high value (0.5) for fast response'"
+Actuator|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)'"
+Actuator|ObjectActuator.loc -> loc:   float  "'Sets the location'"
+Actuator|ObjectActuator.local_angular_velocity -> use_local_angular_velocity:   boolean  "'Angular velocity is defined in local coordinates'"
+Actuator|ObjectActuator.local_force -> use_local_force:   boolean  "'Force is defined in local coordinates'"
+Actuator|ObjectActuator.local_linear_velocity -> use_local_linear_velocity:   boolean  "'Velocity is defined in local coordinates'"
+Actuator|ObjectActuator.local_location -> use_local_location:   boolean  "'Location is defined in local coordinates'"
+Actuator|ObjectActuator.local_rotation -> use_local_rotation:   boolean  "'Rotation is defined in local coordinates'"
+Actuator|ObjectActuator.local_torque -> use_local_torque:   boolean  "'Torque is defined in local coordinates'"
+Actuator|ObjectActuator.mode -> mode:   enum  "'Specify the motion system'"
+Actuator|ObjectActuator.proportional_coefficient -> proportional_coefficient:   float  "'Typical value is 60x integral coefficient'"
+Actuator|ObjectActuator.reference_object -> reference_object:   pointer  "'Reference object for velocity calculation, leave empty for world reference'"
+Actuator|ObjectActuator.rot -> rot:   float  "'Sets the rotation'"
+Actuator|ObjectActuator.servo_limit_x -> use_servo_limit_x:   boolean  "'Set limit to force along the X axis'"
+Actuator|ObjectActuator.servo_limit_y -> use_servo_limit_y:   boolean  "'Set limit to force along the Y axis'"
+Actuator|ObjectActuator.servo_limit_z -> use_servo_limit_z:   boolean  "'Set limit to force along the Z axis'"
+Actuator|ObjectActuator.torque -> torque:   float  "'Sets the torque'"
+Actuator|ParentActuator.compound -> use_compound:   boolean  "'Add this object shape to the parent shape (only if the parent shape is already compound)'"
+Actuator|ParentActuator.ghost -> use_ghost:   boolean  "'Make this object ghost while parented (only if not compound)'"
+Actuator|ParentActuator.mode -> mode:   enum  "'NO DESCRIPTION'"
+Actuator|ParentActuator.object -> object:   pointer  "'Set this object as parent'"
+Actuator|PropertyActuator.mode -> mode:   enum  "'NO DESCRIPTION'"
+Actuator|PropertyActuator.object -> object:   pointer  "'Copy from this Object'"
+Actuator|PropertyActuator.object_property -> object_property:   string  "'Copy this property'"
+Actuator|PropertyActuator.property -> property:   string  "'The name of the property'"
+Actuator|PropertyActuator.value -> value:   string  'The value to use, use "" around strings'
+Actuator|RandomActuator.always_true -> use_always_true:   boolean  "'Always false or always true'"
+Actuator|RandomActuator.chance -> chance:   float  "'Pick a number between 0 and 1. Success if you stay below this value'"
+Actuator|RandomActuator.distribution -> distribution:   enum  "'Choose the type of distribution'"
+Actuator|RandomActuator.float_max -> float_max:   float  "'Choose a number from a range. Upper boundary of the range'"
+Actuator|RandomActuator.float_mean -> float_mean:   float  "'A normal distribution. Mean of the distribution'"
+Actuator|RandomActuator.float_min -> float_min:   float  "'Choose a number from a range. Lower boundary of the range'"
+Actuator|RandomActuator.float_value -> float_value:   float  "'Always return this number'"
+Actuator|RandomActuator.half_life_time -> half_life_time:   float  "'Negative exponential dropoff'"
+Actuator|RandomActuator.int_max -> int_max:   int  "'Choose a number from a range. Upper boundary of the range'"
+Actuator|RandomActuator.int_mean -> int_mean:   float  "'Expected mean value of the distribution'"
+Actuator|RandomActuator.int_min -> int_min:   int  "'Choose a number from a range. Lower boundary of the range'"
+Actuator|RandomActuator.int_value -> int_value:   int  "'Always return this number'"
+Actuator|RandomActuator.property -> property:   string  "'Assign the random value to this property'"
+Actuator|RandomActuator.seed -> seed:   int  "'Initial seed of the random generator. Use Python for more freedom (choose 0 for not random)'"
+Actuator|RandomActuator.standard_derivation -> standard_derivation:   float  "'A normal distribution. Standard deviation of the distribution'"
+Actuator|SceneActuator.camera -> camera:   pointer  "'Set this Camera. Leave empty to refer to self object'"
+Actuator|SceneActuator.mode -> mode:   enum  "'NO DESCRIPTION'"
+Actuator|SceneActuator.scene -> scene:   pointer  "'Set the Scene to be added/removed/paused/resumed'"
+Actuator|ShapeActionActuator.action -> action:   pointer  "'NO DESCRIPTION'"
+Actuator|ShapeActionActuator.blendin -> blendin:   int  "'Number of frames of motion blending'"
+Actuator|ShapeActionActuator.continue_last_frame -> use_continue_last_frame:   boolean  "'Restore last frame when switching on/off, otherwise play from the start each time'"
+Actuator|ShapeActionActuator.frame_end -> frame_end:   int  "'NO DESCRIPTION'"
+Actuator|ShapeActionActuator.frame_property -> frame_property:   string  '"Assign the action\'s current frame number to this property"'
+Actuator|ShapeActionActuator.frame_start -> frame_start:   int  "'NO DESCRIPTION'"
+Actuator|ShapeActionActuator.mode -> mode:   enum  "'Action playback type'"
+Actuator|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'"
+Actuator|ShapeActionActuator.property -> property:   string  "'Use this property to define the Action position'"
+Actuator|SoundActuator.cone_inner_angle_3d -> cone_inner_angle_3d:   float  "'The angle of the inner cone'"
+Actuator|SoundActuator.cone_outer_angle_3d -> cone_outer_angle_3d:   float  "'The angle of the outer cone'"
+Actuator|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'"
+Actuator|SoundActuator.enable_sound_3d -> use_3d_sound:   boolean  "'Enable/Disable 3D Sound'"
+Actuator|SoundActuator.max_distance_3d -> distance_3d_max:   float  "'The maximum distance at which you can hear the sound'"
+Actuator|SoundActuator.maximum_gain_3d -> gain_3d_max:   float  "'The maximum gain of the sound, no matter how near it is'"
+Actuator|SoundActuator.minimum_gain_3d -> gain_3d_min:   float  "'The minimum gain of the sound, no matter how far it is away'"
+Actuator|SoundActuator.mode -> mode:   enum  "'NO DESCRIPTION'"
+Actuator|SoundActuator.pitch -> pitch:   float  "'Sets the pitch of the sound'"
+Actuator|SoundActuator.reference_distance_3d -> reference_distance_3d:   float  "'The distance where the sound has a gain of 1.0'"
+Actuator|SoundActuator.rolloff_factor_3d -> rolloff_factor_3d:   float  "'The influence factor on volume depending on distance'"
+Actuator|SoundActuator.sound -> sound:   pointer  "'NO DESCRIPTION'"
+Actuator|SoundActuator.volume -> volume:   float  "'Sets the initial volume of the sound'"
+Actuator|StateActuator.operation -> operation:   enum  "'Select the bit operation on object state mask'"
+Actuator|StateActuator.state -> states:   boolean  "'NO DESCRIPTION'"
+Actuator|VisibilityActuator.children -> apply_to_children:   boolean  "'Set all the children of this object to the same visibility/occlusion recursively'"
+Actuator|VisibilityActuator.occlusion -> use_occlusion:   boolean  "'Set the object to occlude objects behind it. Initialized from the object type in physics button'"
+Actuator|VisibilityActuator.visible -> use_visible:   boolean  "'Set the objects visible. Initialized from the objects render restriction toggle (access in the outliner)'"
 + * 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"'
@@ -58,84 +200,13 @@ NOTE * CLASS.FROM -> TO:   TYPE  DESCRIPTION
 + * 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'"
-*convert to spaces.active* * Area.active_space -> active_space:   pointer,  "'(read-only)    Space currently being displayed in this area'"
+MAKE PROPERTY OF A COLLECTION * 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 -> draw_type:   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_displace:   float  "'NO DESCRIPTION'"
-*CHECK THIS WITH SIMILAR* * 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 -> fit_length:   float  "'Length to fit array within'"
-+ * ArrayModifier.merge_adjacent_vertices -> use_merge_vertices:   boolean  "'Merge vertices in adjacent duplicates'"
-+ * ArrayModifier.merge_distance -> merge_threshold:   float  "'Limit below which to merge vertices'"
-+ * ArrayModifier.merge_end_vertices -> use_merge_vertices_cap:   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_displace:   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'"
@@ -144,11 +215,6 @@ NOTE * CLASS.FROM -> TO:   TYPE  DESCRIPTION
 + * 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_limit:   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'"
@@ -161,30 +227,28 @@ NOTE * CLASS.FROM -> TO:   TYPE  DESCRIPTION
 + * 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_count:   int  "'How many boids in a line'"
-+ * BoidRuleGoal.object -> object:   pointer  "'Goal object'"
-+ * BoidRuleGoal.predict -> use_predict:   boolean  "'Predict target movement'"
++ * BoidRule|BoidRuleAverageSpeed.level -> level:   float  '"How much velocity\'s z-component is kept constant"'
++ * BoidRule|BoidRuleAverageSpeed.speed -> speed:   float  "'Percentage of maximum speed'"
++ * BoidRule|BoidRuleAverageSpeed.wander -> wander:   float  '"How fast velocity\'s direction is randomized"'
++ * BoidRule|BoidRuleAvoid.fear_factor -> fear_factor:   float  "'Avoid object if danger from it is above this threshold'"
++ * BoidRule|BoidRuleAvoid.object -> object:   pointer  "'Object to avoid'"
++ * BoidRule|BoidRuleAvoid.predict -> use_predict:   boolean  "'Predict target movement'"
++ * BoidRule|BoidRuleAvoidCollision.boids -> use_avoid:   boolean  "'Avoid collision with other boids'"
++ * BoidRule|BoidRuleAvoidCollision.deflectors -> use_avoid_collision:   boolean  "'Avoid collision with deflector objects'"
++ * BoidRule|BoidRuleAvoidCollision.look_ahead -> look_ahead:   float  "'Time to look ahead in seconds'"
++ * BoidRule|BoidRuleFight.distance -> distance:   float  "'Attack boids at max this distance'"
++ * BoidRule|BoidRuleFight.flee_distance -> flee_distance:   float  "'Flee to this distance'"
++ * BoidRule|BoidRuleFollowLeader.distance -> distance:   float  "'Distance behind leader to follow'"
++ * BoidRule|BoidRuleFollowLeader.line -> use_line:   boolean  "'Follow leader in a line'"
++ * BoidRule|BoidRuleFollowLeader.object -> object:   pointer  "'Follow this object instead of a boid'"
++ * BoidRule|BoidRuleFollowLeader.queue_size -> queue_count:   int  "'How many boids in a line'"
++ * BoidRule|BoidRuleGoal.object -> object:   pointer  "'Goal object'"
++ * BoidRule|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'"
@@ -249,131 +313,6 @@ NOTE * CLASS.FROM -> TO:   TYPE  DESCRIPTION
 + * 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 -> cursor_color_add:   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 -> use_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 -> use_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 -> cursor_color_subtract:   float  "'Color of cursor when subtracting'"
-+ * Brush.texture -> texture:   pointer  "'NO DESCRIPTION'"
-+ * Brush.texture_angle_source -> texture_angle_source:   enum  "'NO DESCRIPTION'"
-*THIS NAMES ODD, CHANGE IT?* * 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 -> frame_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'"
@@ -383,9 +322,6 @@ NOTE * CLASS.FROM -> TO:   TYPE  DESCRIPTION
 + * 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'"
@@ -411,18 +347,6 @@ NOTE * CLASS.FROM -> TO:   TYPE  DESCRIPTION
 + * 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'"
-*TODO* * 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'"
@@ -440,157 +364,6 @@ NOTE * CLASS.FROM -> TO:   TYPE  DESCRIPTION
 + * ColorRamp.total -> count:   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'"
@@ -605,34 +378,214 @@ Constraint.proxy_local -> is_proxy_local:   boolean  "'Constraint was added in t
 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'"
++ * Constraint|ActionConstraint.action -> action:   pointer  "'NO DESCRIPTION'"
++ * Constraint|ActionConstraint.frame_end -> frame_end:   int  "'Last frame of the Action to use'"
++ * Constraint|ActionConstraint.frame_start -> frame_start:   int  "'First frame of the Action to use'"
++ * Constraint|ActionConstraint.maximum -> max:   float  "'Maximum value for target channel range'"
++ * Constraint|ActionConstraint.minimum -> min:   float  "'Minimum value for target channel range'"
++ * Constraint|ActionConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
++ * Constraint|ActionConstraint.target -> target:   pointer  "'Target Object'"
++ * Constraint|ActionConstraint.transform_channel -> transform_channel:   enum  "'Transformation channel from the target that is used to key the Action'"
++ * Constraint|ChildOfConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
++ * Constraint|ChildOfConstraint.target -> target:   pointer  "'Target Object'"
++ * Constraint|ChildOfConstraint.use_location_x -> use_location_x:   boolean  "'Use X Location of Parent'"
++ * Constraint|ChildOfConstraint.use_location_y -> use_location_y:   boolean  "'Use Y Location of Parent'"
++ * Constraint|ChildOfConstraint.use_location_z -> use_location_z:   boolean  "'Use Z Location of Parent'"
++ * Constraint|ChildOfConstraint.use_rotation_x -> use_rotation_x:   boolean  "'Use X Rotation of Parent'"
++ * Constraint|ChildOfConstraint.use_rotation_y -> use_rotation_y:   boolean  "'Use Y Rotation of Parent'"
++ * Constraint|ChildOfConstraint.use_rotation_z -> use_rotation_z:   boolean  "'Use Z Rotation of Parent'"
++ * Constraint|ChildOfConstraint.use_scale_x -> use_scale_x:   boolean  "'Use X Scale of Parent'"
++ * Constraint|ChildOfConstraint.use_scale_y -> use_scale_y:   boolean  "'Use Y Scale of Parent'"
++ * Constraint|ChildOfConstraint.use_scale_z -> use_scale_z:   boolean  "'Use Z Scale of Parent'"
++ * Constraint|ClampToConstraint.cyclic -> use_cyclic:   boolean  "'Treat curve as cyclic curve (no clamping to curve bounding box'"
++ * Constraint|ClampToConstraint.main_axis -> main_axis:   enum  "'Main axis of movement'"
++ * Constraint|ClampToConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|CopyLocationConstraint.head_tail -> head_tail:   float  "'Target along length of bone: Head=0, Tail=1'"
+Constraint|CopyLocationConstraint.invert_x -> invert_x:   boolean  "'Invert the X location'"
+Constraint|CopyLocationConstraint.invert_y -> invert_y:   boolean  "'Invert the Y location'"
+Constraint|CopyLocationConstraint.invert_z -> invert_z:   boolean  "'Invert the Z location'"
+Constraint|CopyLocationConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
+Constraint|CopyLocationConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|CopyLocationConstraint.use_offset -> use_offset:   boolean  "'Add original location into copied location'"
+Constraint|CopyLocationConstraint.use_x -> use_x:   boolean  '"Copy the target\'s X location"'
+Constraint|CopyLocationConstraint.use_y -> use_y:   boolean  '"Copy the target\'s Y location"'
+Constraint|CopyLocationConstraint.use_z -> use_z:   boolean  '"Copy the target\'s Z location"'
+Constraint|CopyRotationConstraint.invert_x -> invert_x:   boolean  "'Invert the X rotation'"
+Constraint|CopyRotationConstraint.invert_y -> invert_y:   boolean  "'Invert the Y rotation'"
+Constraint|CopyRotationConstraint.invert_z -> invert_z:   boolean  "'Invert the Z rotation'"
+Constraint|CopyRotationConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
+Constraint|CopyRotationConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|CopyRotationConstraint.use_offset -> use_offset:   boolean  "'Add original rotation into copied rotation'"
+Constraint|CopyRotationConstraint.use_x -> use_x:   boolean  '"Copy the target\'s X rotation"'
+Constraint|CopyRotationConstraint.use_y -> use_y:   boolean  '"Copy the target\'s Y rotation"'
+Constraint|CopyRotationConstraint.use_z -> use_z:   boolean  '"Copy the target\'s Z rotation"'
+Constraint|CopyScaleConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
+Constraint|CopyScaleConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|CopyScaleConstraint.use_offset -> use_offset:   boolean  "'Add original scale into copied scale'"
+Constraint|CopyScaleConstraint.use_x -> use_x:   boolean  '"Copy the target\'s X scale"'
+Constraint|CopyScaleConstraint.use_y -> use_y:   boolean  '"Copy the target\'s Y scale"'
+Constraint|CopyScaleConstraint.use_z -> use_z:   boolean  '"Copy the target\'s Z scale"'
+Constraint|CopyTransformsConstraint.head_tail -> head_tail:   float  "'Target along length of bone: Head=0, Tail=1'"
+Constraint|CopyTransformsConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
+Constraint|CopyTransformsConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|DampedTrackConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
+Constraint|DampedTrackConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|DampedTrackConstraint.track -> track:   enum  "'Axis that points to the target object'"
+Constraint|FloorConstraint.floor_location -> floor_location:   enum  "'Location of target that object will not pass through'"
+Constraint|FloorConstraint.offset -> offset:   float  "'Offset of floor from object origin'"
+Constraint|FloorConstraint.sticky -> use_sticky:   boolean  "'Immobilize object while constrained'"
+Constraint|FloorConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
+Constraint|FloorConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|FloorConstraint.use_rotation -> use_rotation:   boolean  '"Use the target\'s rotation to determine floor"'
+Constraint|FollowPathConstraint.forward -> forward:   enum  "'Axis that points forward along the path'"
+Constraint|FollowPathConstraint.offset -> offset:   int  "'Offset from the position corresponding to the time frame'"
+Constraint|FollowPathConstraint.offset_factor -> offset_factor:   float  "'Percentage value defining target position along length of bone'"
+Constraint|FollowPathConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|FollowPathConstraint.up -> up:   enum  "'Axis that points upward'"
+Constraint|FollowPathConstraint.use_curve_follow -> use_curve_follow:   boolean  "'Object will follow the heading and banking of the curve'"
+Constraint|FollowPathConstraint.use_curve_radius -> use_curve_radius:   boolean  "'Objects scale by the curve radius'"
+Constraint|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'"
+Constraint|KinematicConstraint.axis_reference -> axis_reference:   enum  "'Constraint axis Lock options relative to Bone or Target reference'"
+Constraint|KinematicConstraint.chain_length -> chain_length:   int  "'How many bones are included in the IK effect - 0 uses all bones'"
+Constraint|KinematicConstraint.distance -> distance:   float  "'Radius of limiting sphere'"
+Constraint|KinematicConstraint.ik_type -> ik_type:   enum  "'NO DESCRIPTION'"
+Constraint|KinematicConstraint.iterations -> iterations:   int  "'Maximum number of solving iterations'"
+Constraint|KinematicConstraint.limit_mode -> limit_mode:   enum  "'Distances in relation to sphere of influence to allow'"
+Constraint|KinematicConstraint.orient_weight -> orient_weight:   float  "'For Tree-IK: Weight of orientation control for this target'"
+Constraint|KinematicConstraint.pole_angle -> pole_angle:   float  "'Pole rotation offset'"
+Constraint|KinematicConstraint.pole_subtarget -> pole_subtarget:   string  "'NO DESCRIPTION'"
+Constraint|KinematicConstraint.pole_target -> pole_target:   pointer  "'Object for pole rotation'"
+Constraint|KinematicConstraint.pos_lock_x -> lock_location_x:   boolean  "'Constraint position along X axis'"
+Constraint|KinematicConstraint.pos_lock_y -> lock_location_y:   boolean  "'Constraint position along Y axis'"
+Constraint|KinematicConstraint.pos_lock_z -> lock_location_z:   boolean  "'Constraint position along Z axis'"
+Constraint|KinematicConstraint.rot_lock_x -> lock_rotation_x:   boolean  "'Constraint rotation along X axis'"
+Constraint|KinematicConstraint.rot_lock_y -> lock_rotation_y:   boolean  "'Constraint rotation along Y axis'"
+Constraint|KinematicConstraint.rot_lock_z -> lock_rotation_z:   boolean  "'Constraint rotation along Z axis'"
+Constraint|KinematicConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
+Constraint|KinematicConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|KinematicConstraint.use_position -> use_location:   boolean  "'Chain follows position of target'"
+Constraint|KinematicConstraint.use_rotation -> use_rotation:   boolean  "'Chain follows rotation of target'"
+Constraint|KinematicConstraint.use_stretch -> use_stretch:   boolean  "'Enable IK Stretching'"
+Constraint|KinematicConstraint.use_tail -> use_tail:   boolean  '"Include bone\'s tail as last element in chain"'
+Constraint|KinematicConstraint.use_target -> use_target:   boolean  "'Disable for targetless IK'"
+Constraint|KinematicConstraint.weight -> weight:   float  "'For Tree-IK: Weight of position control for this target'"
+Constraint|LimitDistanceConstraint.distance -> distance:   float  "'Radius of limiting sphere'"
+Constraint|LimitDistanceConstraint.limit_mode -> limit_mode:   enum  "'Distances in relation to sphere of influence to allow'"
+Constraint|LimitDistanceConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
+Constraint|LimitDistanceConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|LimitLocationConstraint.limit_transform -> limit_transform:   boolean  "'Transforms are affected by this constraint as well'"
+Constraint|LimitLocationConstraint.maximum_x -> max_x:   float  "'Highest X value to allow'"
+Constraint|LimitLocationConstraint.maximum_y -> max_y:   float  "'Highest Y value to allow'"
+Constraint|LimitLocationConstraint.maximum_z -> max_z:   float  "'Highest Z value to allow'"
+Constraint|LimitLocationConstraint.minimum_x -> min_x:   float  "'Lowest X value to allow'"
+Constraint|LimitLocationConstraint.minimum_y -> min_y:   float  "'Lowest Y value to allow'"
+Constraint|LimitLocationConstraint.minimum_z -> min_z:   float  "'Lowest Z value to allow'"
+Constraint|LimitLocationConstraint.use_maximum_x -> use_max_x:   boolean  "'Use the maximum X value'"
+Constraint|LimitLocationConstraint.use_maximum_y -> use_max_y:   boolean  "'Use the maximum Y value'"
+Constraint|LimitLocationConstraint.use_maximum_z -> use_max_z:   boolean  "'Use the maximum Z value'"
+Constraint|LimitLocationConstraint.use_minimum_x -> use_min_x:   boolean  "'Use the minimum X value'"
+Constraint|LimitLocationConstraint.use_minimum_y -> use_min_y:   boolean  "'Use the minimum Y value'"
+Constraint|LimitLocationConstraint.use_minimum_z -> use_min_z:   boolean  "'Use the minimum Z value'"
+Constraint|LimitRotationConstraint.limit_transform -> limit_transform:   boolean  "'Transforms are affected by this constraint as well'"
+Constraint|LimitRotationConstraint.maximum_x -> max_x:   float  "'Highest X value to allow'"
+Constraint|LimitRotationConstraint.maximum_y -> max_y:   float  "'Highest Y value to allow'"
+Constraint|LimitRotationConstraint.maximum_z -> max_z:   float  "'Highest Z value to allow'"
+Constraint|LimitRotationConstraint.minimum_x -> min_x:   float  "'Lowest X value to allow'"
+Constraint|LimitRotationConstraint.minimum_y -> min_y:   float  "'Lowest Y value to allow'"
+Constraint|LimitRotationConstraint.minimum_z -> min_z:   float  "'Lowest Z value to allow'"
+Constraint|LimitRotationConstraint.use_limit_x -> use_limit_x:   boolean  "'Use the minimum X value'"
+Constraint|LimitRotationConstraint.use_limit_y -> use_limit_y:   boolean  "'Use the minimum Y value'"
+Constraint|LimitRotationConstraint.use_limit_z -> use_limit_z:   boolean  "'Use the minimum Z value'"
+Constraint|LimitScaleConstraint.limit_transform -> limit_transform:   boolean  "'Transforms are affected by this constraint as well'"
+Constraint|LimitScaleConstraint.maximum_x -> max_x:   float  "'Highest X value to allow'"
+Constraint|LimitScaleConstraint.maximum_y -> max_y:   float  "'Highest Y value to allow'"
+Constraint|LimitScaleConstraint.maximum_z -> max_z:   float  "'Highest Z value to allow'"
+Constraint|LimitScaleConstraint.minimum_x -> min_x:   float  "'Lowest X value to allow'"
+Constraint|LimitScaleConstraint.minimum_y -> min_y:   float  "'Lowest Y value to allow'"
+Constraint|LimitScaleConstraint.minimum_z -> min_z:   float  "'Lowest Z value to allow'"
+Constraint|LimitScaleConstraint.use_maximum_x -> use_max_x:   boolean  "'Use the maximum X value'"
+Constraint|LimitScaleConstraint.use_maximum_y -> use_max_y:   boolean  "'Use the maximum Y value'"
+Constraint|LimitScaleConstraint.use_maximum_z -> use_max_z:   boolean  "'Use the maximum Z value'"
+Constraint|LimitScaleConstraint.use_minimum_x -> use_min_x:   boolean  "'Use the minimum X value'"
+Constraint|LimitScaleConstraint.use_minimum_y -> use_min_y:   boolean  "'Use the minimum Y value'"
+Constraint|LimitScaleConstraint.use_minimum_z -> use_min_z:   boolean  "'Use the minimum Z value'"
+Constraint|LockedTrackConstraint.lock -> lock:   enum  "'Axis that points upward'"
+Constraint|LockedTrackConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
+Constraint|LockedTrackConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|LockedTrackConstraint.track -> track:   enum  "'Axis that points to the target object'"
+Constraint|MaintainVolumeConstraint.axis -> axis:   enum  "'The free scaling axis of the object'"
+Constraint|MaintainVolumeConstraint.volume -> volume:   float  "'Volume of the bone at rest'"
+Constraint|PivotConstraint.enabled_rotation_range -> enabled_rotation_range:   enum  "'Rotation range on which pivoting should occur'"
+Constraint|PivotConstraint.head_tail -> head_tail:   float  "'Target along length of bone: Head=0, Tail=1'"
+Constraint|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"'
+Constraint|PivotConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
+Constraint|PivotConstraint.target -> target:   pointer  "'Target Object, defining the position of the pivot when defined'"
+Constraint|PivotConstraint.use_relative_position -> use_relative_location:   boolean  "'Offset will be an absolute point in space instead of relative to the target'"
+Constraint|PythonConstraint.number_of_targets -> number_of_targets:   int  "'Usually only 1-3 are needed'"
+Constraint|PythonConstraint.script_error -> has_script_error:   boolean,  "'(read-only)    The linked Python script has thrown an error'"
+Constraint|PythonConstraint.targets -> targets:   collection,  "'(read-only)    Target Objects'"
+Constraint|PythonConstraint.text -> text:   pointer  "'The text object that contains the Python script'"
+Constraint|PythonConstraint.use_targets -> use_targets:   boolean  "'Use the targets indicated in the constraint panel'"
+Constraint|RigidBodyJointConstraint.axis_x -> axis_x:   float  "'Rotate pivot on X axis in degrees'"
+Constraint|RigidBodyJointConstraint.axis_y -> axis_y:   float  "'Rotate pivot on Y axis in degrees'"
+Constraint|RigidBodyJointConstraint.axis_z -> axis_z:   float  "'Rotate pivot on Z axis in degrees'"
+Constraint|RigidBodyJointConstraint.child -> child:   pointer  "'Child object'"
+NEGATE * Constraint|RigidBodyJointConstraint.disable_linked_collision -> use_linked_collision:   boolean  "'Disable collision between linked bodies'"
+Constraint|RigidBodyJointConstraint.draw_pivot -> show_pivot:   boolean  "'Display the pivot point and rotation in 3D view'"
+Constraint|RigidBodyJointConstraint.pivot_type -> pivot_type:   enum  "'NO DESCRIPTION'"
+Constraint|RigidBodyJointConstraint.pivot_x -> pivot_x:   float  "'Offset pivot on X'"
+Constraint|RigidBodyJointConstraint.pivot_y -> pivot_y:   float  "'Offset pivot on Y'"
+Constraint|RigidBodyJointConstraint.pivot_z -> pivot_z:   float  "'Offset pivot on Z'"
+Constraint|RigidBodyJointConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|ShrinkwrapConstraint.distance -> distance:   float  "'Distance to Target'"
+Constraint|ShrinkwrapConstraint.shrinkwrap_type -> shrinkwrap_type:   enum  "'Selects type of shrinkwrap algorithm for target position'"
+Constraint|ShrinkwrapConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|ShrinkwrapConstraint.use_x -> use_x:   boolean  "'Projection over X Axis'"
+Constraint|ShrinkwrapConstraint.use_y -> use_y:   boolean  "'Projection over Y Axis'"
+Constraint|ShrinkwrapConstraint.use_z -> use_z:   boolean  "'Projection over Z Axis'"
+Constraint|SplineIKConstraint.chain_length -> chain_length:   int  "'How many bones are included in the chain'"
+Constraint|SplineIKConstraint.chain_offset -> use_chain_offset:   boolean  "'Offset the entire chain relative to the root joint'"
+Constraint|SplineIKConstraint.even_divisions -> use_even_divisions:   boolean  "'Ignore the relative lengths of the bones when fitting to the curve'"
+Constraint|SplineIKConstraint.joint_bindings -> joint_bindings:   float  "'(EXPERIENCED USERS ONLY) The relative positions of the joints along the chain as percentages'"
+Constraint|SplineIKConstraint.target -> target:   pointer  "'Curve that controls this relationship'"
+Constraint|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'"
+Constraint|SplineIKConstraint.xz_scaling_mode -> xz_scale_mode:   enum  "'Method used for determining the scaling of the X and Z axes of the bones'"
+Constraint|SplineIKConstraint.y_stretch -> use_y_stretch:   boolean  "'Stretch the Y axis of the bones to fit the curve'"
+Constraint|StretchToConstraint.bulge -> bulge:   float  "'Factor between volume variation and stretching'"
+Constraint|StretchToConstraint.head_tail -> head_tail:   float  "'Target along length of bone: Head=0, Tail=1'"
+Constraint|StretchToConstraint.keep_axis -> keep_axis:   enum  "'Axis to maintain during stretch'"
+Constraint|StretchToConstraint.original_length -> original_length:   float  "'Length at rest position'"
+Constraint|StretchToConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
+Constraint|StretchToConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|StretchToConstraint.volume -> volume:   enum  '"Maintain the object\'s volume as it stretches"'
+Constraint|TrackToConstraint.head_tail -> head_tail:   float  "'Target along length of bone: Head=0, Tail=1'"
+Constraint|TrackToConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
+Constraint|TrackToConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|TrackToConstraint.target_z -> use_target_z:   boolean  '"Target\'s Z axis, not World Z axis, will constraint the Up direction"'
+Constraint|TrackToConstraint.track -> track:   enum  "'Axis that points to the target object'"
+Constraint|TrackToConstraint.up -> up:   enum  "'Axis that points upward'"
+Constraint|TransformConstraint.extrapolate_motion -> use_motion_extrapolate:   boolean  "'Extrapolate ranges'"
+Constraint|TransformConstraint.from_max_x -> from_max_x:   float  "'Top range of X axis source motion'"
+Constraint|TransformConstraint.from_max_y -> from_max_y:   float  "'Top range of Y axis source motion'"
+Constraint|TransformConstraint.from_max_z -> from_max_z:   float  "'Top range of Z axis source motion'"
+Constraint|TransformConstraint.from_min_x -> from_min_x:   float  "'Bottom range of X axis source motion'"
+Constraint|TransformConstraint.from_min_y -> from_min_y:   float  "'Bottom range of Y axis source motion'"
+Constraint|TransformConstraint.from_min_z -> from_min_z:   float  "'Bottom range of Z axis source motion'"
+Constraint|TransformConstraint.map_from -> map_from:   enum  "'The transformation type to use from the target'"
+Constraint|TransformConstraint.map_to -> map_to:   enum  "'The transformation type to affect of the constrained object'"
+Constraint|TransformConstraint.map_to_x_from -> map_to_x_from:   enum  '"The source axis constrained object\'s X axis uses"'
+Constraint|TransformConstraint.map_to_y_from -> map_to_y_from:   enum  '"The source axis constrained object\'s Y axis uses"'
+Constraint|TransformConstraint.map_to_z_from -> map_to_z_from:   enum  '"The source axis constrained object\'s Z axis uses"'
+Constraint|TransformConstraint.subtarget -> subtarget:   string  "'NO DESCRIPTION'"
+Constraint|TransformConstraint.target -> target:   pointer  "'Target Object'"
+Constraint|TransformConstraint.to_max_x -> to_max_x:   float  "'Top range of X axis destination motion'"
+Constraint|TransformConstraint.to_max_y -> to_max_y:   float  "'Top range of Y axis destination motion'"
+Constraint|TransformConstraint.to_max_z -> to_max_z:   float  "'Top range of Z axis destination motion'"
+Constraint|TransformConstraint.to_min_x -> to_min_x:   float  "'Bottom range of X axis destination motion'"
+Constraint|TransformConstraint.to_min_y -> to_min_y:   float  "'Bottom range of Y axis destination motion'"
+Constraint|TransformConstraint.to_min_z -> to_min_z:   float  "'Bottom range of Z axis destination motion'"
 Context.area -> area:   pointer,  "'(read-only)'"
 Context.main -> main:   pointer,  "'(read-only)'"
 Context.manager -> manager:   pointer,  "'(read-only)'"
@@ -645,82 +598,16 @@ 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'"
+Controller|ExpressionController.expression -> expression:   string  "'NO DESCRIPTION'"
+Controller|PythonController.debug -> use_debug:   boolean  "'Continuously reload the module from disk for editing external modules without restarting'"
+Controller|PythonController.mode -> mode:   enum  "'Python script type (textblock or module - faster)'"
+Controller|PythonController.module -> module:   string  'Module name and function to run e.g. "someModule.main". Internal texts and external python files can be used'
+Controller|PythonController.text -> text:   pointer  "'Text datablock with the python script'"
 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'"
@@ -734,55 +621,7 @@ 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'"
@@ -822,9 +661,6 @@ 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)'"
@@ -853,39 +689,6 @@ 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'"
@@ -902,8 +705,6 @@ 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'"
@@ -917,16 +718,6 @@ EnvironmentMap.resolution -> resolution:   int  "'Pixel resolution of the render
 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'"
@@ -940,14 +731,6 @@ Event.oskey -> is_pressed_cmd:   boolean,  "'(read-only)    True when the Cmd ke
 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'"
@@ -972,55 +755,46 @@ NEGATE * FModifier.disabled -> use:   boolean,  "'(read-only)    F-Curve Modifie
 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'"
+FModifier|FModifierCycles.after_cycles -> after_cycles:   float  "'Maximum number of cycles to allow after last keyframe. (0 = infinite)'"
+FModifier|FModifierCycles.after_mode -> after_mode:   enum  "'Cycling mode to use after last keyframe'"
+FModifier|FModifierCycles.before_cycles -> before_cycles:   float  "'Maximum number of cycles to allow before first keyframe. (0 = infinite)'"
+FModifier|FModifierCycles.before_mode -> before_mode:   enum  "'Cycling mode to use before first keyframe'"
+FModifier|FModifierEnvelope.control_points -> control_points:   collection,  "'(read-only)    Control points defining the shape of the envelope'"
+FModifier|FModifierEnvelope.default_maximum -> default_max:   float  "'Upper distance from Reference Value for 1:1 default influence'"
+FModifier|FModifierEnvelope.default_minimum -> default_min:   float  "'Lower distance from Reference Value for 1:1 default influence'"
+FModifier|FModifierEnvelope.reference_value -> reference_value:   float  '"Value that envelope\'s influence is centered around / based on"'
+FModifier|FModifierFunctionGenerator.additive -> use_additive:   boolean  "'Values generated by this modifier are applied on top of the existing values instead of overwriting them'"
+FModifier|FModifierFunctionGenerator.amplitude -> amplitude:   float  "'Scale factor determining the maximum/minimum values'"
+FModifier|FModifierFunctionGenerator.function_type -> function_type:   enum  "'Type of built-in function to use'"
+FModifier|FModifierFunctionGenerator.phase_multiplier -> phase_multiplier:   float  '"Scale factor determining the \'speed\' of the function"'
+FModifier|FModifierFunctionGenerator.phase_offset -> phase_offset:   float  "'Constant factor to offset time by for function'"
+FModifier|FModifierFunctionGenerator.value_offset -> value_offset:   float  "'Constant factor to offset values by'"
+FModifier|FModifierGenerator.additive -> use_additive:   boolean  "'Values generated by this modifier are applied on top of the existing values instead of overwriting them'"
+FModifier|FModifierGenerator.coefficients -> coefficients:   float  '"Coefficients for \'x\' (starting from lowest power of x^0)"'
+FModifier|FModifierGenerator.mode -> mode:   enum  "'Type of generator to use'"
+FModifier|FModifierGenerator.poly_order -> poly_order:   int  '"The highest power of \'x\' for this polynomial. (number of coefficients - 1)"'
+FModifier|FModifierLimits.maximum_x -> max_x:   float  "'Highest X value to allow'"
+FModifier|FModifierLimits.maximum_y -> max_y:   float  "'Highest Y value to allow'"
+FModifier|FModifierLimits.minimum_x -> min_x:   float  "'Lowest X value to allow'"
+FModifier|FModifierLimits.minimum_y -> min_y:   float  "'Lowest Y value to allow'"
+FModifier|FModifierLimits.use_maximum_x -> use_max_x:   boolean  "'Use the maximum X value'"
+FModifier|FModifierLimits.use_maximum_y -> use_max_y:   boolean  "'Use the maximum Y value'"
+FModifier|FModifierLimits.use_minimum_x -> use_min_x:   boolean  "'Use the minimum X value'"
+FModifier|FModifierLimits.use_minimum_y -> use_min_y:   boolean  "'Use the minimum Y value'"
+FModifier|FModifierNoise.depth -> depth:   int  "'Amount of fine level detail present in the noise'"
+FModifier|FModifierNoise.modification -> modification:   enum  "'Method of modifying the existing F-Curve'"
+FModifier|FModifierNoise.phase -> phase:   float  "'A random seed for the noise effect'"
+FModifier|FModifierNoise.size -> size:   float  "'Scaling (in time) of the noise'"
+FModifier|FModifierNoise.strength -> strength:   float  "'Amplitude of the noise - the amount that it modifies the underlying curve'"
+FModifier|FModifierStepped.frame_end -> frame_end:   float  '"Frame that modifier\'s influence ends (if applicable)"'
+FModifier|FModifierStepped.frame_start -> frame_start:   float  '"Frame that modifier\'s influence starts (if applicable)"'
+FModifier|FModifierStepped.offset -> offset:   float  '"Reference number of frames before frames get held. Use to get hold for \'1-3\' vs \'5-7\' holding patterns"'
+FModifier|FModifierStepped.step_size -> step_size:   float  "'Number of frames to hold each value'"
+FModifier|FModifierStepped.use_frame_end -> use_frame_end:   boolean  '"Restrict modifier to only act before its \'end\' frame"'
+FModifier|FModifierStepped.use_frame_start -> use_frame_start:   boolean  '"Restrict modifier to only act after its \'start\' frame"'
 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"'
@@ -1082,40 +856,64 @@ 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'"
+FluidSettings|ControlFluidSettings.active -> use:   boolean  "'Object contributes to the fluid simulation'"
+FluidSettings|ControlFluidSettings.attraction_radius -> attraction_radius:   float  "'Specifies the force field radius around the control object'"
+FluidSettings|ControlFluidSettings.attraction_strength -> attraction_strength:   float  "'Force strength for directional attraction towards the control object'"
+FluidSettings|ControlFluidSettings.end_time -> end_time:   float  "'Specifies time when the control particles are deactivated'"
+FluidSettings|ControlFluidSettings.quality -> quality:   float  "'Specifies the quality which is used for object sampling. (higher = better but slower)'"
+FluidSettings|ControlFluidSettings.reverse_frames -> use_reverse_frames:   boolean  "'Reverse control object movement'"
+FluidSettings|ControlFluidSettings.start_time -> start_time:   float  "'Specifies time when the control particles are activated'"
+FluidSettings|ControlFluidSettings.velocity_radius -> velocity_radius:   float  "'Specifies the force field radius around the control object'"
+FluidSettings|ControlFluidSettings.velocity_strength -> velocity_strength:   float  '"Force strength of how much of the control object\'s velocity is influencing the fluid velocity"'
+FluidSettings|DomainFluidSettings.compressibility -> compressibility:   float  "'Allowed compressibility due to gravitational force for standing fluid. (directly affects simulation step size)'"
+FluidSettings|DomainFluidSettings.end_time -> end_time:   float  "'Simulation time of the last blender frame'"
+FluidSettings|DomainFluidSettings.generate_particles -> generate_particles:   float  "'Amount of particles to generate (0=off, 1=normal, >1=more)'"
+FluidSettings|DomainFluidSettings.generate_speed_vectors -> use_speed_vectors:   boolean  "'Generate speed vectors for vector blur'"
+FluidSettings|DomainFluidSettings.gravity -> gravity:   float  "'Gravity in X, Y and Z direction'"
+FluidSettings|DomainFluidSettings.grid_levels -> grid_levels:   int  "'Number of coarsened grids to use (-1 for automatic)'"
+FluidSettings|DomainFluidSettings.memory_estimate -> memory_estimate:   string,  "'(read-only)    Estimated amount of memory needed for baking the domain'"
+FluidSettings|DomainFluidSettings.override_time -> use_time_override:   boolean  '"Use a custom start and end time (in seconds) instead of the scene\'s timeline"'
+FluidSettings|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'"
+FluidSettings|DomainFluidSettings.path -> path:   string  "'Directory (and/or filename prefix) to store baked fluid simulation files in'"
+FluidSettings|DomainFluidSettings.preview_resolution -> preview_resolution:   int  "'Preview resolution in X,Y and Z direction'"
+FluidSettings|DomainFluidSettings.real_world_size -> real_world_size:   float  "'Size of the simulation domain in metres'"
+FluidSettings|DomainFluidSettings.render_display_mode -> render_display_mode:   enum  "'How to display the mesh for rendering'"
+FluidSettings|DomainFluidSettings.resolution -> resolution:   int  "'Domain resolution in X,Y and Z direction'"
+FluidSettings|DomainFluidSettings.reverse_frames -> use_reverse_frames:   boolean  "'Reverse fluid frames'"
+FluidSettings|DomainFluidSettings.slip_type -> slip_type:   enum  "'NO DESCRIPTION'"
+FluidSettings|DomainFluidSettings.start_time -> start_time:   float  "'Simulation time of the first blender frame'"
+FluidSettings|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'"
+FluidSettings|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!'"
+FluidSettings|DomainFluidSettings.tracer_particles -> tracer_particles:   int  "'Number of tracer particles to generate'"
+FluidSettings|DomainFluidSettings.viewport_display_mode -> viewport_display_mode:   enum  "'How to display the mesh in the viewport'"
+FluidSettings|DomainFluidSettings.viscosity_base -> viscosity_base:   float  "'Viscosity setting: value that is multiplied by 10 to the power of (exponent*-1)'"
+FluidSettings|DomainFluidSettings.viscosity_exponent -> viscosity_exponent:   int  "'Negative exponent for the viscosity value (to simplify entering small values e.g. 5*10^-6.)'"
+FluidSettings|DomainFluidSettings.viscosity_preset -> viscosity_preset:   enum  "'Set viscosity of the fluid to a preset value, or use manual input'"
+FluidSettings|FluidFluidSettings.active -> use:   boolean  "'Object contributes to the fluid simulation'"
+FluidSettings|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'"
+FluidSettings|FluidFluidSettings.initial_velocity -> initial_velocity:   float  "'Initial velocity of fluid'"
+FluidSettings|FluidFluidSettings.volume_initialization -> volume_initialization:   enum  "'Volume initialization type'"
+FluidSettings|InflowFluidSettings.active -> use:   boolean  "'Object contributes to the fluid simulation'"
+FluidSettings|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'"
+FluidSettings|InflowFluidSettings.inflow_velocity -> inflow_velocity:   float  "'Initial velocity of fluid'"
+FluidSettings|InflowFluidSettings.local_coordinates -> use_local_coordinates:   boolean  "'Use local coordinates for inflow. (e.g. for rotating objects)'"
+FluidSettings|InflowFluidSettings.volume_initialization -> volume_initialization:   enum  "'Volume initialization type'"
+FluidSettings|ObstacleFluidSettings.active -> use:   boolean  "'Object contributes to the fluid simulation'"
+FluidSettings|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'"
+FluidSettings|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'"
+FluidSettings|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'"
+FluidSettings|ObstacleFluidSettings.slip_type -> slip_type:   enum  "'NO DESCRIPTION'"
+FluidSettings|ObstacleFluidSettings.volume_initialization -> volume_initialization:   enum  "'Volume initialization type'"
+FluidSettings|OutflowFluidSettings.active -> use:   boolean  "'Object contributes to the fluid simulation'"
+FluidSettings|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'"
+FluidSettings|OutflowFluidSettings.volume_initialization -> volume_initialization:   enum  "'Volume initialization type'"
+FluidSettings|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)'"
+FluidSettings|ParticleFluidSettings.drops -> use_drops:   boolean  "'Show drop particles'"
+FluidSettings|ParticleFluidSettings.floats -> use_floats:   boolean  "'Show floating foam particles'"
+FluidSettings|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'"
+FluidSettings|ParticleFluidSettings.path -> path:   string  "'Directory (and/or filename prefix) to store and load particles from'"
+FluidSettings|ParticleFluidSettings.tracer -> use_tracer:   boolean  "'Show tracer particles'"
 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'"
@@ -1142,11 +940,6 @@ GPencilLayer.use_onion_skinning -> use_onion_skinning:   boolean  "'Ghost frames
 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'"
@@ -1190,6 +983,11 @@ GameObjectSettings.visible_state -> states_visible:   boolean  "'State determini
 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'"
+GameProperty|GameBooleanProperty.value -> value:   boolean  "'Property value'"
+GameProperty|GameFloatProperty.value -> value:   float  "'Property value'"
+GameProperty|GameIntProperty.value -> value:   int  "'Property value'"
+GameProperty|GameStringProperty.value -> value:   string  "'Property value'"
+GameProperty|GameTimerProperty.value -> value:   float  "'Property value'"
 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'"
@@ -1201,29 +999,10 @@ GameSoftBodySettings.position_iterations -> position_iterations:   int  "'Positi
 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'"
@@ -1239,98 +1018,919 @@ 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'"
+IDPropertyGroup|NetRenderJob.name -> name:   string  "'NO DESCRIPTION'"
+IDPropertyGroup|NetRenderSettings.active_blacklisted_slave_index -> active_blacklisted_slave_index:   int  "'NO DESCRIPTION'"
+IDPropertyGroup|NetRenderSettings.active_job_index -> active_job_index:   int  "'NO DESCRIPTION'"
+IDPropertyGroup|NetRenderSettings.active_slave_index -> active_slave_index:   int  "'NO DESCRIPTION'"
+IDPropertyGroup|NetRenderSettings.chunks -> chunks:   int  "'Number of frame to dispatch to each slave in one chunk'"
+IDPropertyGroup|NetRenderSettings.job_category -> job_category:   string  "'Category of the job'"
+IDPropertyGroup|NetRenderSettings.job_id -> job_id:   string  "'id of the last sent render job'"
+IDPropertyGroup|NetRenderSettings.job_name -> job_name:   string  "'Name of the job'"
+IDPropertyGroup|NetRenderSettings.jobs -> jobs:   collection,  "'(read-only)'"
+IDPropertyGroup|NetRenderSettings.master_broadcast -> use_master_broadcast:   boolean  "'broadcast master server address on local network'"
+IDPropertyGroup|NetRenderSettings.master_clear -> use_master_clear:   boolean  "'delete saved files on exit'"
+IDPropertyGroup|NetRenderSettings.mode -> mode:   enum  "'Mode of operation of this instance'"
+IDPropertyGroup|NetRenderSettings.path -> path:   string  "'Path for temporary files'"
+IDPropertyGroup|NetRenderSettings.priority -> priority:   int  "'Priority of the job'"
+IDPropertyGroup|NetRenderSettings.server_address -> server_address:   string  "'IP or name of the master render server'"
+IDPropertyGroup|NetRenderSettings.server_port -> server_port:   int  "'port of the master render server'"
+IDPropertyGroup|NetRenderSettings.slave_clear -> use_slave_clear:   boolean  "'delete downloaded files on exit'"
+IDPropertyGroup|NetRenderSettings.slave_outputlog -> use_slave_output_log:   boolean  "'Output render text log to console as well as sending it to the master'"
+IDPropertyGroup|NetRenderSettings.slave_thumb -> use_slave_thumb:   boolean  "'Generate thumbnails on slaves instead of master'"
+IDPropertyGroup|NetRenderSettings.slaves -> slaves:   collection,  "'(read-only)'"
+IDPropertyGroup|NetRenderSettings.slaves_blacklist -> slaves_blacklist:   collection,  "'(read-only)'"
+IDPropertyGroup|NetRenderSlave.name -> name:   string  "'NO DESCRIPTION'"
+IDPropertyGroup|OperatorFileListElement.name -> name:   string  "'the name of a file or directory within a file list'"
+IDPropertyGroup|OperatorMousePath.loc -> loc:   float  "'Mouse location'"
+IDPropertyGroup|OperatorMousePath.time -> time:   float  "'Time of mouse location'"
+IDPropertyGroup|OperatorStrokeElement.location -> location:   float  "'NO DESCRIPTION'"
+IDPropertyGroup|OperatorStrokeElement.mouse -> mouse:   float  "'NO DESCRIPTION'"
+IDPropertyGroup|OperatorStrokeElement.pen_flip -> pen_flip:   boolean  "'NO DESCRIPTION'"
+IDPropertyGroup|OperatorStrokeElement.pressure -> pressure:   float  "'Tablet pressure'"
+IDPropertyGroup|OperatorStrokeElement.time -> time:   float  "'NO DESCRIPTION'"
+IDPropertyGroup|PoseTemplate.name -> name:   string  "'NO DESCRIPTION'"
+IDPropertyGroup|PoseTemplateSettings.active_template_index -> active_template_index:   int  "'NO DESCRIPTION'"
+IDPropertyGroup|PoseTemplateSettings.generate_def_rig -> use_generate_deform_rig:   boolean  "'Create a copy of the metarig, constrainted by the generated rig'"
+IDPropertyGroup|PoseTemplateSettings.templates -> templates:   collection,  "'(read-only)'"
++ * ID|Action.fcurves -> fcurves:   collection,  "'(read-only)    The individual F-Curves that make up the Action'"
++ * ID|Action.groups -> groups:   collection,  "'(read-only)    Convenient groupings of F-Curves'"
++ * ID|Action.pose_markers -> pose_markers:   collection,  "'(read-only)    Markers specific to this Action, for labeling poses'"
++ * ID|Armature.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
++ * ID|Armature.auto_ik -> use_auto_ik:   boolean  "'Add temporaral IK constraints while grabbing bones in Pose Mode'"
++ * ID|Armature.bones -> bones:   collection,  "'(read-only)'"
++ * ID|Armature.deform_envelope -> use_deform_envelopes:   boolean  "'Enable Bone Envelopes when defining deform'"
++ * ID|Armature.deform_quaternion -> use_deform_preserve_volume:   boolean  "'Deform rotation interpolation with quaternions'"
++ * ID|Armature.deform_vertexgroups -> use_deform_vertex_groups:   boolean  "'Enable Vertex Groups when defining deform'"
++ * ID|Armature.delay_deform -> use_deform_delay:   boolean  '"Don\'t deform children when manipulating bones in Pose Mode"'
++ * ID|Armature.draw_axes -> show_axes:   boolean  "'Draw bone axes'"
++ * ID|Armature.draw_custom_bone_shapes -> show_bone_custom_shapes:   boolean  "'Draw bones with their custom shapes'"
++ * ID|Armature.draw_group_colors -> show_group_colors:   boolean  "'Draw bone group colors'"
++ * ID|Armature.draw_names -> show_names:   boolean  "'Draw bone names'"
++ * ID|Armature.drawtype -> draw_type:   enum  "'NO DESCRIPTION'"
++ * ID|Armature.edit_bones -> edit_bones:   collection,  "'(read-only)'"
++ * ID|Armature.ghost_frame_end -> ghost_frame_end:   int  '"End frame of range of Ghosts to display (not for \'Around Current Frame\' Onion-skinning method)"'
++ * ID|Armature.ghost_frame_start -> ghost_frame_start:   int  '"Starting frame of range of Ghosts to display (not for \'Around Current Frame\' Onion-skinning method)"'
++ * ID|Armature.ghost_only_selected -> show_only_ghost_selected:   boolean  "'NO DESCRIPTION'"
++ * ID|Armature.ghost_size -> ghost_size:   int  '"Frame step for Ghosts (not for \'On Keyframes\' Onion-skinning method)"'
++ * ID|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)"'
++ * ID|Armature.ghost_type -> ghost_type:   enum  "'Method of Onion-skinning for active Action'"
++ * ID|Armature.layer -> layers:   boolean  "'Armature layer visibility'"
++ * ID|Armature.layer_protection -> layers_protected:   boolean  "'Protected layers in Proxy Instances are restored to Proxy settings on file reload and undo'"
++ * ID|Armature.pose_position -> pose_position:   enum  "'Show armature in binding pose or final posed state'"
++ * ID|Armature.x_axis_mirror -> use_mirror_x:   boolean  "'Apply changes to matching bone on opposite side of X-Axis'"
++ * ID|Brush.add_col -> cursor_color_add:   float  "'Color of cursor when adding'"
++ * ID|Brush.autosmooth_factor -> autosmooth_factor:   float  "'Amount of smoothing to automatically apply to each stroke'"
++ * ID|Brush.blend -> blend:   enum  "'Brush blending mode'"
++ * ID|Brush.clone_alpha -> clone_alpha:   float  "'Opacity of clone image display'"
++ * ID|Brush.clone_image -> clone_image:   pointer  "'Image for clone tool'"
++ * ID|Brush.clone_offset -> clone_offset:   float  "'NO DESCRIPTION'"
++ * ID|Brush.color -> color:   float  "'NO DESCRIPTION'"
++ * ID|Brush.crease_pinch_factor -> crease_pinch_factor:   float  "'How much the crease brush pinches'"
++ * ID|Brush.curve -> curve:   pointer,  "'(read-only)    Editable falloff curve'"
++ * ID|Brush.direction -> direction:   enum  "'Mapping type to use for this image in the game engine'"
++ * ID|Brush.edge_to_edge -> use_edge_to_edge:   boolean  "'Drag anchor brush from edge-to-edge'"
++ * ID|Brush.icon_filepath -> icon_filepath:   string  "'File path to brush icon'"
++ * ID|Brush.imagepaint_tool -> imagepaint_tool:   enum  "'NO DESCRIPTION'"
++ * ID|Brush.jitter -> jitter:   float  "'Jitter the position of the brush while painting'"
++ * ID|Brush.normal_weight -> normal_weight:   float  "'How much grab will pull vertexes out of surface during a grab'"
++ * ID|Brush.plane_offset -> plane_offset:   float  "'Adjusts plane on which the brush acts towards or away from the object surface'"
++ * ID|Brush.plane_trim -> plane_trim:   float  "'If a vertex is further from offset plane than this then it is not affected'"
++ * ID|Brush.rate -> rate:   float  "'Interval between paints for Airbrush'"
++ * ID|Brush.restore_mesh -> use_restore_mesh:   boolean  "'Allows a single dot to be carefully positioned'"
++ * ID|Brush.sculpt_plane -> sculpt_plane:   enum  "'NO DESCRIPTION'"
++ * ID|Brush.sculpt_tool -> sculpt_tool:   enum  "'NO DESCRIPTION'"
++ * ID|Brush.size -> size:   int  "'Diameter of the brush'"
++ * ID|Brush.smooth_stroke_factor -> smooth_stroke_factor:   float  "'Higher values give a smoother stroke'"
++ * ID|Brush.smooth_stroke_radius -> smooth_stroke_radius:   int  "'Minimum distance from last point before stroke continues'"
++ * ID|Brush.spacing -> spacing:   float  "'Spacing between brush stamps'"
++ * ID|Brush.strength -> strength:   float  "'The amount of pressure on the brush'"
++ * ID|Brush.stroke_method -> stroke_method:   enum  "'NO DESCRIPTION'"
++ * ID|Brush.sub_col -> cursor_color_subtract:   float  "'Color of cursor when subtracting'"
++ * ID|Brush.texture -> texture:   pointer  "'NO DESCRIPTION'"
++ * ID|Brush.texture_angle_source -> texture_angle_source:   enum  "'NO DESCRIPTION'"
+ODD NAME CHANGE IT? * ID|Brush.texture_angle_source_no_random -> texture_angle_source_no_random:   enum  'NO DESCRIPTION'
++ * ID|Brush.texture_overlay_alpha -> texture_overlay_alpha:   int  "'NO DESCRIPTION'"
++ * ID|Brush.texture_sample_bias -> texture_sample_bias:   float  "'Value added to texture samples'"
++ * ID|Brush.texture_slot -> texture_slot:   pointer,  "'(read-only)'"
++ * ID|Brush.unprojected_radius -> unprojected_radius:   float  "'Radius of brush in Blender units'"
++ * ID|Brush.use_accumulate -> use_accumulate:   boolean  "'Accumulate stroke dabs on top of each other'"
++ * ID|Brush.use_adaptive_space -> use_adaptive_space:   boolean  "'Space daubs according to surface orientation instead of screen space'"
++ * ID|Brush.use_airbrush -> use_airbrush:   boolean  "'Keep applying paint effect while holding mouse (spray)'"
++ * ID|Brush.use_alpha -> use_alpha:   boolean  "'When this is disabled, lock alpha while painting'"
++ * ID|Brush.use_anchor -> use_anchor:   boolean  "'Keep the brush anchored to the initial location'"
++ * ID|Brush.use_custom_icon -> use_custom_icon:   boolean  "'Set the brush icon from an image file'"
++ * ID|Brush.use_frontface -> use_frontface:   boolean  "'Brush only affects vertexes that face the viewer'"
++ * ID|Brush.use_inverse_smooth_pressure -> use_inverse_smooth_pressure:   boolean  "'Lighter pressure causes more smoothing to be applied'"
++ * ID|Brush.use_jitter_pressure -> use_pressure_jitter:   boolean  "'Enable tablet pressure sensitivity for jitter'"
++ * ID|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'"
++ * ID|Brush.use_offset_pressure -> use_offset_pressure:   boolean  "'Enable tablet pressure sensitivity for offset'"
++ * ID|Brush.use_original_normal -> use_original_normal:   boolean  "'When locked keep using normal of surface where stroke was initiated'"
++ * ID|Brush.use_paint_sculpt -> use_paint_sculpt:   boolean  "'Use this brush in sculpt mode'"
++ * ID|Brush.use_paint_texture -> use_paint_texture:   boolean  "'Use this brush in texture paint mode'"
++ * ID|Brush.use_paint_vertex -> use_paint_vertex:   boolean  "'Use this brush in vertex paint mode'"
++ * ID|Brush.use_paint_weight -> use_paint_weight:   boolean  "'Use this brush in weight paint mode'"
++ * ID|Brush.use_persistent -> use_persistent:   boolean  "'Sculpts on a persistent layer of the mesh'"
++ * ID|Brush.use_plane_trim -> use_plane_trim:   boolean  "'Enable Plane Trim'"
++ * ID|Brush.use_rake -> use_rake:   boolean  "'Rotate the brush texture to match the stroke direction'"
++ * ID|Brush.use_random_rotation -> use_random_rotation:   boolean  "'Rotate the brush texture at random'"
++ * ID|Brush.use_size_pressure -> use_pressure_size:   boolean  "'Enable tablet pressure sensitivity for size'"
++ * ID|Brush.use_smooth_stroke -> use_smooth_stroke:   boolean  "'Brush lags behind mouse and follows a smoother path'"
++ * ID|Brush.use_space -> use_space:   boolean  "'Limit brush application to the distance specified by spacing'"
++ * ID|Brush.use_space_atten -> use_space_atten:   boolean  "'Automatically adjusts strength to give consistent results for different spacings'"
++ * ID|Brush.use_spacing_pressure -> use_pressure_spacing:   boolean  "'Enable tablet pressure sensitivity for spacing'"
++ * ID|Brush.use_strength_pressure -> use_pressure_strength:   boolean  "'Enable tablet pressure sensitivity for strength'"
++ * ID|Brush.use_texture_overlay -> use_texture_overlay:   boolean  "'Show texture in viewport'"
++ * ID|Brush.use_wrap -> use_wrap:   boolean  "'Enable torus wrapping while painting'"
++ * ID|Brush.vertexpaint_tool -> vertexpaint_tool:   enum  "'NO DESCRIPTION'"
++ * ID|Camera.angle -> angle:   float  "'Perspective Camera lens field of view in degrees'"
++ * ID|Camera.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
++ * ID|Camera.clip_end -> clip_end:   float  "'Camera far clipping distance'"
++ * ID|Camera.clip_start -> clip_start:   float  "'Camera near clipping distance'"
++ * ID|Camera.dof_distance -> dof_distance:   float  "'Distance to the focus point for depth of field'"
++ * ID|Camera.dof_object -> dof_object:   pointer  "'Use this object to define the depth of field focal point'"
++ * ID|Camera.draw_size -> draw_size:   float  "'Apparent size of the Camera object in the 3D View'"
++ * ID|Camera.lens -> lens:   float  "'Perspective Camera lens value in millimeters'"
++ * ID|Camera.lens_unit -> lens_unit:   enum  "'Unit to edit lens in for the user interface'"
++ * ID|Camera.ortho_scale -> ortho_scale:   float  "'Orthographic Camera scale (similar to zoom)'"
++ * ID|Camera.panorama -> use_panorama:   boolean  "'Render the scene with a cylindrical camera for pseudo-fisheye lens effects'"
++ * ID|Camera.passepartout_alpha -> passepartout_alpha:   float  "'Opacity (alpha) of the darkened overlay in Camera view'"
++ * ID|Camera.shift_x -> shift_x:   float  "'Perspective Camera horizontal shift'"
++ * ID|Camera.shift_y -> shift_y:   float  "'Perspective Camera vertical shift'"
++ * ID|Camera.show_limits -> show_limits:   boolean  "'Draw the clipping range and focus point on the camera'"
++ * ID|Camera.show_mist -> show_mist:   boolean  "'Draw a line from the Camera to indicate the mist area'"
++ * ID|Camera.show_name -> show_name:   boolean  '"Show the active Camera\'s name in Camera view"'
++ * ID|Camera.show_passepartout -> show_passepartout:   boolean  "'Show a darkened overlay outside the image area in Camera view'"
++ * ID|Camera.show_title_safe -> show_title_safe:   boolean  "'Show indicators for the title safe zone in Camera view'"
++ * ID|Camera.type -> type:   enum  "'Camera types'"
+ID|Curve.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
+ID|Curve.auto_texspace -> use_auto_texspace:   boolean  '"Adjusts active object\'s texture space automatically when transforming object"'
+ID|Curve.back -> use_fill_back:   boolean  "'Draw filled back for extruded/beveled curves'"
+ID|Curve.bevel_depth -> bevel_depth:   float  "'Bevel depth when not using a bevel object'"
+ID|Curve.bevel_object -> bevel_object:   pointer  "'Curve object name that defines the bevel shape'"
+ID|Curve.bevel_resolution -> bevel_resolution:   int  "'Bevel resolution when depth is non-zero and no specific bevel object has been defined'"
+ID|Curve.dimensions -> dimensions:   enum  "'Select 2D or 3D curve type'"
+ID|Curve.draw_handles -> show_handles:   boolean  "'Display bezier handles in editmode'"
+ID|Curve.draw_normals -> show_normals:   boolean  "'Display 3D curve normals in editmode'"
+ID|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"'
+ID|Curve.extrude -> extrude:   float  "'Amount of curve extrusion when not using a bevel object'"
+ID|Curve.front -> use_fill_front:   boolean  "'Draw filled front for extruded/beveled curves'"
+ID|Curve.map_along_length -> use_map_along_length:   boolean  "'Generate texture mapping coordinates following the curve direction, rather than the local bounding box'"
+ID|Curve.materials -> materials:   collection,  "'(read-only)'"
+ID|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"'
+ID|Curve.render_resolution_u -> render_resolution_u:   int  "'Surface resolution in U direction used while rendering. Zero skips this property'"
+ID|Curve.render_resolution_v -> render_resolution_v:   int  "'Surface resolution in V direction used while rendering. Zero skips this property'"
+ID|Curve.resolution_u -> resolution_u:   int  "'Surface resolution in U direction'"
+ID|Curve.resolution_v -> resolution_v:   int  "'Surface resolution in V direction'"
+ID|Curve.shape_keys -> shape_keys:   pointer,  "'(read-only)'"
+ID|Curve.splines -> splines:   collection,  "'(read-only)    Collection of splines in this curve data object'"
+ID|Curve.taper_object -> taper_object:   pointer  "'Curve object name that defines the taper (width)'"
+ID|Curve.texspace_loc -> texspace_loc:   float  "'Texture space location'"
+ID|Curve.texspace_size -> texspace_size:   float  "'Texture space size'"
+ID|Curve.twist_mode -> twist_mode:   enum  "'The type of tilt calculation for 3D Curves'"
+ID|Curve.twist_smooth -> twist_smooth:   float  "'Smoothing iteration for tangents'"
+ID|Curve.use_deform_bounds -> use_deform_bounds:   boolean  "'Use the mesh bounds to clamp the deformation'"
+ID|Curve.use_deform_fill -> use_fill_deform:   boolean  "'Fill curve after applying deformation'"
+ID|Curve.use_path -> use_path:   boolean  "'Enable the curve to become a translation path'"
+ID|Curve.use_path_follow -> use_path_follow:   boolean  "'Make curve path children to rotate along the path'"
+ID|Curve.use_radius -> use_radius:   boolean  "'Option for paths: apply the curve radius with path following it and deforming'"
+ID|Curve.use_stretch -> use_stretch:   boolean  "'Option for curve-deform: makes deformed child to stretch along entire path'"
+ID|Curve.use_time_offset -> use_time_offset:   boolean  "'Children will use Time Offset value as path distance offset'"
+ID|Curve.width -> width:   float  "'Scale the original width (1.0) based on given factor'"
+ID|Curve|SurfaceCurve.map_along_length -> use_map_along_length:   boolean  "'Generate texture mapping coordinates following the curve direction, rather than the local bounding box'"
+ID|Curve|TextCurve.active_textbox -> active_textbox:   int  "'NO DESCRIPTION'"
+ID|Curve|TextCurve.body -> body:   string  "'contents of this text object'"
+ID|Curve|TextCurve.body_format -> body_format:   collection,  "'(read-only)    Stores the style of each character'"
+ID|Curve|TextCurve.edit_format -> edit_format:   pointer,  "'(read-only)    Editing settings character formatting'"
+ID|Curve|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'"
+ID|Curve|TextCurve.fast -> use_fast_editing:   boolean  '"Don\'t fill polygons while editing"'
+ID|Curve|TextCurve.font -> font:   pointer  "'NO DESCRIPTION'"
+ID|Curve|TextCurve.line_dist -> line_distance:   float  "'NO DESCRIPTION'"
+ID|Curve|TextCurve.map_along_length -> use_map_along_length:   boolean  "'Generate texture mapping coordinates following the curve direction, rather than the local bounding box'"
+ID|Curve|TextCurve.offset_x -> offset_x:   float  "'Horizontal offset from the object origin'"
+ID|Curve|TextCurve.offset_y -> offset_y:   float  "'Vertical offset from the object origin'"
+ID|Curve|TextCurve.shear -> shear:   float  "'Italic angle of the characters'"
+ID|Curve|TextCurve.small_caps_scale -> small_caps_scale:   float  "'Scale of small capitals'"
+ID|Curve|TextCurve.spacemode -> spacemode:   enum  "'Text align from the object center'"
+ID|Curve|TextCurve.spacing -> spacing:   float  "'NO DESCRIPTION'"
+ID|Curve|TextCurve.text_on_curve -> text_on_curve:   pointer  "'Curve deforming text object'"
+ID|Curve|TextCurve.text_size -> text_size:   float  "'NO DESCRIPTION'"
+ID|Curve|TextCurve.textboxes -> textboxes:   collection,  "'(read-only)'"
+ID|Curve|TextCurve.ul_height -> ul_height:   float  "'NO DESCRIPTION'"
+ID|Curve|TextCurve.ul_position -> ul_position:   float  "'Vertical position of underline'"
+ID|Curve|TextCurve.word_spacing -> word_spacing:   float  "'NO DESCRIPTION'"
+ID|GreasePencil.draw_mode -> draw_mode:   enum  "'NO DESCRIPTION'"
+ID|GreasePencil.layers -> layers:   collection,  "'(read-only)'"
+ID|GreasePencil.use_stroke_endpoints -> use_stroke_endpoints:   boolean  "'Only use the first and last parts of the stroke for snapping'"
+ID|Group.dupli_offset -> dupli_offset:   float  "'Offset from the origin to use when instancing as DupliGroup'"
+ID|Group.layer -> layers:   boolean  "'Layers visible when this groups is instanced as a dupli'"
+ID|Group.objects -> objects:   collection,  "'(read-only)    A collection of this groups objects'"
+ID|Image.animated -> use_animation:   boolean  "'Use as animated texture in the game engine'"
+ID|Image.animation_end -> animation_end:   int  "'End frame of an animated texture'"
+ID|Image.animation_speed -> animation_speed:   int  "'Speed of the animation in frames per second'"
+ID|Image.animation_start -> animation_start:   int  "'Start frame of an animated texture'"
+ID|Image.bindcode -> bindcode:   int,  "'(read-only)    OpenGL bindcode'"
+ID|Image.clamp_x -> use_clamp_x:   boolean  "'Disable texture repeating horizontally'"
+ID|Image.clamp_y -> use_clamp_y:   boolean  "'Disable texture repeating vertically'"
+ID|Image.depth -> depth:   int,  "'(read-only)    Image bit depth'"
+ID|Image.dirty -> is_dirty:   boolean,  "'(read-only)    Image has changed and is not saved'"
+ID|Image.display_aspect -> display_aspect:   float  "'Display Aspect for this image, does not affect rendering'"
+ID|Image.field_order -> field_order:   enum  "'Order of video fields. Select which lines are displayed first'"
+ID|Image.fields -> use_fields:   boolean  "'Use fields of the image'"
+ID|Image.file_format -> file_format:   enum  "'Format used for re-saving this file'"
+ID|Image.filepath -> filepath:   string  "'Image/Movie file name'"
+ID|Image.filepath_raw -> filepath_raw:   string  "'Image/Movie file name (without data refreshing)'"
+ID|Image.generated_height -> generated_height:   int  "'Generated image height'"
+ID|Image.generated_type -> generated_type:   enum  "'Generated image type'"
+ID|Image.generated_width -> generated_width:   int  "'Generated image width'"
+ID|Image.has_data -> has_data:   boolean,  "'(read-only)    True if this image has data'"
+ID|Image.mapping -> mapping:   enum  "'Mapping type to use for this image in the game engine'"
+ID|Image.packed_file -> packed_file:   pointer,  "'(read-only)'"
+ID|Image.premultiply -> use_premultiply:   boolean  "'Convert RGB from key alpha to premultiplied alpha'"
+ID|Image.size -> size:   int,  "'(read-only)    Width and height in pixels, zero when image data cant be loaded'"
+ID|Image.source -> source:   enum  "'Where the image comes from'"
+ID|Image.tiles -> use_tiles:   boolean  "'Use of tilemode for faces (default shift-LMB to pick the tile for selected faces)'"
+ID|Image.tiles_x -> tiles_x:   int  "'Degree of repetition in the X direction'"
+ID|Image.tiles_y -> tiles_y:   int  "'Degree of repetition in the Y direction'"
+ID|Image.type -> type:   enum,  "'(read-only)    How to generate the image'"
+ID|Key.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
+ID|Key.keys -> keys:   collection,  "'(read-only)    Shape keys'"
+ID|Key.reference_key -> reference_key:   pointer,  "'(read-only)'"
+ID|Key.relative -> use_relative:   boolean  "'Makes shape keys relative'"
+ID|Key.slurph -> slurph:   int  "'Creates a delay in amount of frames in applying keypositions, first vertex goes first'"
+ID|Key.user -> user:   pointer,  "'(read-only)    Datablock using these shape keys'"
+ID|Lamp.active_texture -> active_texture:   pointer  "'Active texture slot being displayed'"
+ID|Lamp.active_texture_index -> active_texture_index:   int  "'Index of active texture slot'"
+ID|Lamp.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
+ID|Lamp.color -> color:   float  "'Light color'"
+ID|Lamp.diffuse -> use_diffuse:   boolean  "'Lamp does diffuse shading'"
+ID|Lamp.distance -> distance:   float  "'Falloff distance - the light is at half the original intensity at this point'"
+ID|Lamp.energy -> energy:   float  "'Amount of light that the lamp emits'"
+ID|Lamp.layer -> use_own_layer:   boolean  "'Illuminates objects only on the same layer the lamp is on'"
+ID|Lamp.negative -> use_negative:   boolean  "'Lamp casts negative light'"
+ID|Lamp.specular -> use_specular:   boolean  "'Lamp creates specular highlights'"
+ID|Lamp.texture_slots -> texture_slots:   collection,  "'(read-only)    Texture slots defining the mapping and influence of textures'"
+ID|Lamp.type -> type:   enum  "'Type of Lamp'"
++ * ID|Lamp|AreaLamp.dither -> use_dither:   boolean  "'Use 2x2 dithering for sampling  (Constant Jittered sampling)'"
++ * ID|Lamp|AreaLamp.gamma -> gamma:   float  "'Light gamma correction value'"
++ * ID|Lamp|AreaLamp.jitter -> use_jitter:   boolean  "'Use noise for sampling  (Constant Jittered sampling)'"
++ * ID|Lamp|AreaLamp.only_shadow -> use_only_shadow:   boolean  "'Causes light to cast shadows only without illuminating objects'"
++ * ID|Lamp|AreaLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:   float  "'Threshold for Adaptive Sampling (Raytraced shadows)'"
++ * ID|Lamp|AreaLamp.shadow_color -> shadow_color:   float  "'Color of shadows cast by the lamp'"
++ * ID|Lamp|AreaLamp.shadow_layer -> use_shadow_layer:   boolean  "'Causes only objects on the same layer to cast shadows'"
++ * ID|Lamp|AreaLamp.shadow_method -> shadow_method:   enum  "'Method to compute lamp shadow with'"
++ * ID|Lamp|AreaLamp.shadow_ray_samples_x -> shadow_ray_samples_x:   int  "'Amount of samples taken extra (samples x samples)'"
++ * ID|Lamp|AreaLamp.shadow_ray_samples_y -> shadow_ray_samples_y:   int  "'Amount of samples taken extra (samples x samples)'"
++ * ID|Lamp|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'"
++ * ID|Lamp|AreaLamp.shadow_soft_size -> shadow_soft_size:   float  "'Light size for ray shadow sampling (Raytraced shadows)'"
++ * ID|Lamp|AreaLamp.shape -> shape:   enum  "'Shape of the area lamp'"
++ * ID|Lamp|AreaLamp.size -> size:   float  "'Size of the area of the area Lamp, X direction size for Rectangle shapes'"
++ * ID|Lamp|AreaLamp.size_y -> size_y:   float  "'Size of the area of the area Lamp in the Y direction for Rectangle shapes'"
++ * ID|Lamp|AreaLamp.umbra -> use_umbra:   boolean  "'Emphasize parts that are fully shadowed (Constant Jittered sampling)'"
+ID|Lamp|PointLamp.falloff_curve -> falloff_curve:   pointer,  "'(read-only)    Custom Lamp Falloff Curve'"
+ID|Lamp|PointLamp.falloff_type -> falloff_type:   enum  "'Intensity Decay with distance'"
+ID|Lamp|PointLamp.linear_attenuation -> linear_attenuation:   float  "'Linear distance attenuation'"
+ID|Lamp|PointLamp.only_shadow -> use_only_shadow:   boolean  "'Causes light to cast shadows only without illuminating objects'"
+ID|Lamp|PointLamp.quadratic_attenuation -> quadratic_attenuation:   float  "'Quadratic distance attenuation'"
+ID|Lamp|PointLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:   float  "'Threshold for Adaptive Sampling (Raytraced shadows)'"
+ID|Lamp|PointLamp.shadow_color -> shadow_color:   float  "'Color of shadows cast by the lamp'"
+ID|Lamp|PointLamp.shadow_layer -> use_shadow_layer:   boolean  "'Causes only objects on the same layer to cast shadows'"
+ID|Lamp|PointLamp.shadow_method -> shadow_method:   enum  "'Method to compute lamp shadow with'"
+ID|Lamp|PointLamp.shadow_ray_samples -> shadow_ray_samples:   int  "'Amount of samples taken extra (samples x samples)'"
+ID|Lamp|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'"
+ID|Lamp|PointLamp.shadow_soft_size -> shadow_soft_size:   float  "'Light size for ray shadow sampling (Raytraced shadows)'"
+ID|Lamp|PointLamp.sphere -> use_sphere:   boolean  "'Sets light intensity to zero beyond lamp distance'"
+ID|Lamp|SpotLamp.auto_clip_end -> use_auto_clip_end:   boolean  "'Automatic calculation of clipping-end, based on visible vertices'"
+ID|Lamp|SpotLamp.auto_clip_start -> use_auto_clip_start:   boolean  "'Automatic calculation of clipping-start, based on visible vertices'"
+ID|Lamp|SpotLamp.compression_threshold -> compression_threshold:   float  "'Deep shadow map compression threshold'"
+ID|Lamp|SpotLamp.falloff_curve -> falloff_curve:   pointer,  "'(read-only)    Custom Lamp Falloff Curve'"
+ID|Lamp|SpotLamp.falloff_type -> falloff_type:   enum  "'Intensity Decay with distance'"
+ID|Lamp|SpotLamp.halo -> use_halo:   boolean  "'Renders spotlight with a volumetric halo (Buffer Shadows)'"
+ID|Lamp|SpotLamp.halo_intensity -> halo_intensity:   float  '"Brightness of the spotlight\'s halo cone  (Buffer Shadows)"'
+ID|Lamp|SpotLamp.halo_step -> halo_step:   int  "'Volumetric halo sampling frequency'"
+ID|Lamp|SpotLamp.linear_attenuation -> linear_attenuation:   float  "'Linear distance attenuation'"
+ID|Lamp|SpotLamp.only_shadow -> use_only_shadow:   boolean  "'Causes light to cast shadows only without illuminating objects'"
+ID|Lamp|SpotLamp.quadratic_attenuation -> quadratic_attenuation:   float  "'Quadratic distance attenuation'"
+ID|Lamp|SpotLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:   float  "'Threshold for Adaptive Sampling (Raytraced shadows)'"
+ID|Lamp|SpotLamp.shadow_buffer_bias -> shadow_buffer_bias:   float  "'Shadow buffer sampling bias'"
+ID|Lamp|SpotLamp.shadow_buffer_clip_end -> shadow_buffer_clip_end:   float  "'Shadow map clip end beyond which objects will not generate shadows'"
+ID|Lamp|SpotLamp.shadow_buffer_clip_start -> shadow_buffer_clip_start:   float  "'Shadow map clip start: objects closer will not generate shadows'"
+ID|Lamp|SpotLamp.shadow_buffer_samples -> shadow_buffer_samples:   int  "'Number of shadow buffer samples'"
+ID|Lamp|SpotLamp.shadow_buffer_size -> shadow_buffer_size:   int  "'Resolution of the shadow buffer, higher values give crisper shadows but use more memory'"
+ID|Lamp|SpotLamp.shadow_buffer_soft -> shadow_buffer_soft:   float  "'Size of shadow buffer sampling area'"
+ID|Lamp|SpotLamp.shadow_buffer_type -> shadow_buffer_type:   enum  "'Type of shadow buffer'"
+ID|Lamp|SpotLamp.shadow_color -> shadow_color:   float  "'Color of shadows cast by the lamp'"
+ID|Lamp|SpotLamp.shadow_filter_type -> shadow_filter_type:   enum  "'Type of shadow filter (Buffer Shadows)'"
+ID|Lamp|SpotLamp.shadow_layer -> use_shadow_layer:   boolean  "'Causes only objects on the same layer to cast shadows'"
+ID|Lamp|SpotLamp.shadow_method -> shadow_method:   enum  "'Method to compute lamp shadow with'"
+ID|Lamp|SpotLamp.shadow_ray_samples -> shadow_ray_samples:   int  "'Amount of samples taken extra (samples x samples)'"
+ID|Lamp|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'"
+ID|Lamp|SpotLamp.shadow_sample_buffers -> shadow_sample_buffers:   enum  "'Number of shadow buffers to render for better AA, this increases memory usage'"
+ID|Lamp|SpotLamp.shadow_soft_size -> shadow_soft_size:   float  "'Light size for ray shadow sampling (Raytraced shadows)'"
+ID|Lamp|SpotLamp.show_cone -> show_cone:   boolean  "'Draw transparent cone in 3D view to visualize which objects are contained in it'"
+ID|Lamp|SpotLamp.sphere -> use_sphere:   boolean  "'Sets light intensity to zero beyond lamp distance'"
+ID|Lamp|SpotLamp.spot_blend -> spot_blend:   float  "'The softness of the spotlight edge'"
+ID|Lamp|SpotLamp.spot_size -> spot_size:   float  "'Angle of the spotlight beam in degrees'"
+ID|Lamp|SpotLamp.square -> use_square:   boolean  "'Casts a square spot light shape'"
+ID|Lamp|SunLamp.only_shadow -> use_only_shadow:   boolean  "'Causes light to cast shadows only without illuminating objects'"
+ID|Lamp|SunLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:   float  "'Threshold for Adaptive Sampling (Raytraced shadows)'"
+ID|Lamp|SunLamp.shadow_color -> shadow_color:   float  "'Color of shadows cast by the lamp'"
+ID|Lamp|SunLamp.shadow_layer -> use_shadow_layer:   boolean  "'Causes only objects on the same layer to cast shadows'"
+ID|Lamp|SunLamp.shadow_method -> shadow_method:   enum  "'Method to compute lamp shadow with'"
+ID|Lamp|SunLamp.shadow_ray_samples -> shadow_ray_samples:   int  "'Amount of samples taken extra (samples x samples)'"
+ID|Lamp|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'"
+ID|Lamp|SunLamp.shadow_soft_size -> shadow_soft_size:   float  "'Light size for ray shadow sampling (Raytraced shadows)'"
+ID|Lamp|SunLamp.sky -> sky:   pointer,  "'(read-only)    Sky related settings for sun lamps'"
+ID|Lattice.interpolation_type_u -> interpolation_type_u:   enum  "'NO DESCRIPTION'"
+ID|Lattice.interpolation_type_v -> interpolation_type_v:   enum  "'NO DESCRIPTION'"
+ID|Lattice.interpolation_type_w -> interpolation_type_w:   enum  "'NO DESCRIPTION'"
+ID|Lattice.outside -> use_outside:   boolean  "'Only draw, and take into account, the outer vertices'"
+ID|Lattice.points -> points:   collection,  "'(read-only)    Points of the lattice'"
+ID|Lattice.points_u -> points_u:   int  "'Points in U direction'"
+ID|Lattice.points_v -> points_v:   int  "'Points in V direction'"
+ID|Lattice.points_w -> points_w:   int  "'Points in W direction'"
+ID|Lattice.shape_keys -> shape_keys:   pointer,  "'(read-only)'"
+ID|Lattice.vertex_group -> vertex_group:   string  "'Vertex group to apply the influence of the lattice'"
+ID|Library.filepath -> filepath:   string  "'Path to the library .blend file'"
+ID|Library.parent -> parent:   pointer,  "'(read-only)'"
+ID|Material.active_node_material -> active_node_material:   pointer  "'Active node material'"
+ID|Material.active_texture -> active_texture:   pointer  "'Active texture slot being displayed'"
+ID|Material.active_texture_index -> active_texture_index:   int  "'Index of active texture slot'"
+ID|Material.alpha -> alpha:   float  "'Alpha transparency of the material'"
+ID|Material.ambient -> ambient:   float  "'Amount of global ambient color the material receives'"
+ID|Material.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
+ID|Material.cast_approximate -> use_cast_approximate:   boolean  "'Allow this material to cast shadows when using approximate ambient occlusion.'"
+ID|Material.cast_buffer_shadows -> use_cast_buffer_shadows:   boolean  "'Allow this material to cast shadows from shadow buffer lamps'"
+ID|Material.cast_shadows_only -> use_cast_shadows_only:   boolean  "'Makes objects with this material appear invisible, only casting shadows (not rendered)'"
+ID|Material.cubic -> use_cubic:   boolean  "'Use cubic interpolation for diffuse values, for smoother transitions'"
+ID|Material.darkness -> darkness:   float  "'Minnaert darkness'"
+ID|Material.diffuse_color -> diffuse_color:   float  "'NO DESCRIPTION'"
+ID|Material.diffuse_fresnel -> diffuse_fresnel:   float  "'Power of Fresnel'"
+ID|Material.diffuse_fresnel_factor -> diffuse_fresnel_factor:   float  "'Blending factor of Fresnel'"
+ID|Material.diffuse_intensity -> diffuse_intensity:   float  "'Amount of diffuse reflection'"
+ID|Material.diffuse_ramp -> diffuse_ramp:   pointer,  "'(read-only)    Color ramp used to affect diffuse shading'"
+ID|Material.diffuse_ramp_blend -> diffuse_ramp_blend:   enum  "'NO DESCRIPTION'"
+ID|Material.diffuse_ramp_factor -> diffuse_ramp_factor:   float  "'Blending factor (also uses alpha in Colorband)'"
+ID|Material.diffuse_ramp_input -> diffuse_ramp_input:   enum  "'NO DESCRIPTION'"
+ID|Material.diffuse_shader -> diffuse_shader:   enum  "'NO DESCRIPTION'"
+ID|Material.diffuse_toon_size -> diffuse_toon_size:   float  "'Size of diffuse toon area'"
+ID|Material.diffuse_toon_smooth -> diffuse_toon_smooth:   float  "'Smoothness of diffuse toon area'"
+ID|Material.emit -> emit:   float  "'Amount of light to emit'"
+NEGATE * ID|Material.exclude_mist -> use_mist:   boolean  "'Excludes this material from mist effects (in world settings)'"
+ID|Material.face_texture -> use_face_texture:   boolean  '"Replaces the object\'s base color with color from face assigned image textures"'
+ID|Material.face_texture_alpha -> use_face_texture_alpha:   boolean  '"Replaces the object\'s base alpha value with alpha from face assigned image textures"'
+ID|Material.full_oversampling -> use_full_oversampling:   boolean  "'Force this material to render full shading/textures for all anti-aliasing samples'"
+ID|Material.halo -> halo:   pointer,  "'(read-only)    Halo settings for the material'"
+ID|Material.invert_z -> invert_z:   boolean  '"Renders material\'s faces with an inverted Z buffer (scanline only)"'
+ID|Material.light_group -> light_group:   pointer  "'Limit lighting to lamps in this Group'"
+ID|Material.light_group_exclusive -> use_light_group_exclusive:   boolean  "'Material uses the light group exclusively - these lamps are excluded from other scene lighting'"
+ID|Material.mirror_color -> mirror_color:   float  "'Mirror color of the material'"
+ID|Material.node_tree -> node_tree:   pointer,  "'(read-only)    Node tree for node based materials'"
+ID|Material.object_color -> use_object_color:   boolean  "'Modulate the result with a per-object color'"
+ID|Material.only_shadow -> use_only_shadow:   boolean  '"Renders shadows as the material\'s alpha value, making materials transparent except for shadowed areas"'
+ID|Material.physics -> physics:   pointer,  "'(read-only)    Game physics settings'"
+ID|Material.preview_render_type -> preview_render_type:   enum  "'Type of preview render'"
+ID|Material.ray_shadow_bias -> use_ray_shadow_bias:   boolean  "'Prevents raytraced shadow errors on surfaces with smooth shaded normals (terminator problem)'"
+ID|Material.raytrace_mirror -> raytrace_mirror:   pointer,  "'(read-only)    Raytraced reflection settings for the material'"
+ID|Material.raytrace_transparency -> raytrace_transparency:   pointer,  "'(read-only)    Raytraced transparency settings for the material'"
+ID|Material.receive_transparent_shadows -> use_transparent_shadows:   boolean  "'Allow this object to receive transparent shadows casted through other objects'"
+ID|Material.roughness -> rough:   float  "'Oren-Nayar Roughness'"
+ID|Material.shadeless -> use_shadeless:   boolean  "'Makes this material insensitive to light or shadow'"
+ID|Material.shadow_buffer_bias -> shadow_buffer_bias:   float  "'Factor to multiply shadow buffer bias with (0 is ignore.)'"
+ID|Material.shadow_casting_alpha -> shadow_cast_alpha:   float  "'Shadow casting alpha, in use for Irregular and Deep shadow buffer'"
+ID|Material.shadow_ray_bias -> shadow_ray_bias:   float  "'Shadow raytracing bias to prevent terminator problems on shadow boundary'"
+ID|Material.shadows -> use_shadows:   boolean  "'Allows this material to receive shadows'"
+ID|Material.specular_alpha -> specular_alpha:   float  "'Alpha transparency for specular areas'"
+ID|Material.specular_color -> specular_color:   float  "'Specular color of the material'"
+ID|Material.specular_hardness -> specular_hard:   int  "'NO DESCRIPTION'"
+ID|Material.specular_intensity -> specular_intensity:   float  "'NO DESCRIPTION'"
+ID|Material.specular_ior -> specular_ior:   float  "'NO DESCRIPTION'"
+ID|Material.specular_ramp -> specular_ramp:   pointer,  "'(read-only)    Color ramp used to affect specular shading'"
+ID|Material.specular_ramp_blend -> specular_ramp_blend:   enum  "'NO DESCRIPTION'"
+ID|Material.specular_ramp_factor -> specular_ramp_factor:   float  "'Blending factor (also uses alpha in Colorband)'"
+ID|Material.specular_ramp_input -> specular_ramp_input:   enum  "'NO DESCRIPTION'"
+ID|Material.specular_shader -> specular_shader:   enum  "'NO DESCRIPTION'"
+ID|Material.specular_slope -> specular_slope:   float  "'The standard deviation of surface slope'"
+ID|Material.specular_toon_size -> specular_toon_size:   float  "'Size of specular toon area'"
+ID|Material.specular_toon_smooth -> specular_toon_smooth:   float  "'Smoothness of specular toon area'"
+ID|Material.strand -> strand:   pointer,  "'(read-only)    Strand settings for the material'"
+ID|Material.subsurface_scattering -> subsurface_scattering:   pointer,  "'(read-only)    Subsurface scattering settings for the material'"
+ID|Material.tangent_shading -> use_tangent_shading:   boolean  '"Use the material\'s tangent vector instead of the normal for shading - for anisotropic shading effects"'
+ID|Material.texture_slots -> texture_slots:   collection,  "'(read-only)    Texture slots defining the mapping and influence of textures'"
+ID|Material.traceable -> use_traceable:   boolean  "'Include this material and geometry that uses it in ray tracing calculations'"
+ID|Material.translucency -> translucency:   float  "'Amount of diffuse shading on the back side'"
+ID|Material.transparency -> use_transparency:   boolean  "'Render material as transparent'"
+ID|Material.transparency_method -> transparency_method:   enum  "'Method to use for rendering transparency'"
+ID|Material.type -> type:   enum  "'Material type defining how the object is rendered'"
+ID|Material.use_diffuse_ramp -> use_diffuse_ramp:   boolean  "'Toggle diffuse ramp operations'"
+ID|Material.use_nodes -> use_nodes:   boolean  "'Use shader nodes to render the material'"
+ID|Material.use_sky -> use_sky:   boolean  "'Renders this material with zero alpha, with sky background in place (scanline only)'"
+ID|Material.use_specular_ramp -> use_specular_ramp:   boolean  "'Toggle specular ramp operations'"
+ID|Material.use_textures -> use_textures:   boolean  "'Enable/Disable each texture'"
+ID|Material.vertex_color_light -> use_vertex_color_light:   boolean  "'Add vertex colors as additional lighting'"
+ID|Material.vertex_color_paint -> use_vertex_color_paint:   boolean  '"Replaces object base color with vertex colors (multiplies with \'texture face\' face assigned textures)"'
+ID|Material.volume -> volume:   pointer,  "'(read-only)    Volume settings for the material'"
+ID|Material.z_offset -> z_offset:   float  "'Gives faces an artificial offset in the Z buffer for Z transparency'"
+ID|Mesh.active_uv_texture -> active_uv_texture:   pointer  "'Active UV texture'"
+ID|Mesh.active_uv_texture_index -> active_uv_texture_index:   int  "'Active UV texture index'"
+ID|Mesh.active_vertex_color -> active_vertex_color:   pointer  "'Active vertex color layer'"
+ID|Mesh.active_vertex_color_index -> active_vertex_color_index:   int  "'Active vertex color index'"
+ID|Mesh.all_edges -> show_all_edges:   boolean  "'Displays all edges for wireframe in all view modes in the 3D view'"
+ID|Mesh.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
+ID|Mesh.auto_texspace -> use_auto_texspace:   boolean  '"Adjusts active object\'s texture space automatically when transforming object"'
+ID|Mesh.autosmooth -> use_autosmooth:   boolean  '"Treats all set-smoothed faces with angles less than the specified angle as \'smooth\' during render"'
+ID|Mesh.autosmooth_angle -> autosmooth_angle:   int  '"Defines maximum angle between face normals that \'Auto Smooth\' will operate on"'
+ID|Mesh.double_sided -> show_double_sided:   boolean  "'Render/display the mesh with double or single sided lighting'"
+ID|Mesh.draw_bevel_weights -> show_bevel_weights:   boolean  "'Displays weights created for the Bevel modifier'"
+ID|Mesh.draw_creases -> show_creases:   boolean  "'Displays creases created for subsurf weighting'"
+ID|Mesh.draw_edge_angle -> show_edge_angle:   boolean  "'Displays the angles in the selected edges in degrees'"
+ID|Mesh.draw_edge_length -> show_edge_length:   boolean  "'Displays selected edge lengths, Using global values when set in the transform panel'"
+ID|Mesh.draw_edges -> show_edges:   boolean  "'Displays selected edges using highlights in the 3D view and UV editor'"
+ID|Mesh.draw_face_area -> show_face_area:   boolean  "'Displays the area of selected faces'"
+ID|Mesh.draw_faces -> show_faces:   boolean  "'Displays all faces as shades in the 3D view and UV editor'"
+ID|Mesh.draw_normals -> show_normals:   boolean  "'Displays face normals as lines'"
+ID|Mesh.draw_seams -> show_seams:   boolean  "'Displays UV unwrapping seams'"
+ID|Mesh.draw_sharp -> show_sharp:   boolean  "'Displays sharp edges, used with the EdgeSplit modifier'"
+ID|Mesh.draw_vertex_normals -> show_vertex_normals:   boolean  "'Displays vertex normals as lines'"
+ID|Mesh.edges -> edges:   collection,  "'(read-only)    Edges of the mesh'"
+ID|Mesh.faces -> faces:   collection,  "'(read-only)    Faces of the mesh'"
+ID|Mesh.float_layers -> float_layers:   collection,  "'(read-only)'"
+ID|Mesh.int_layers -> int_layers:   collection,  "'(read-only)'"
+ID|Mesh.materials -> materials:   collection,  "'(read-only)'"
+ID|Mesh.shape_keys -> shape_keys:   pointer,  "'(read-only)'"
+ID|Mesh.sticky -> sticky:   collection,  "'(read-only)    Sticky texture coordinates'"
+ID|Mesh.string_layers -> string_layers:   collection,  "'(read-only)'"
+ID|Mesh.texco_mesh -> texco_mesh:   pointer  "'Derive texture coordinates from another mesh'"
+ID|Mesh.texspace_loc -> texspace_loc:   float  "'Texture space location'"
+ID|Mesh.texspace_size -> texspace_size:   float  "'Texture space size'"
+ID|Mesh.texture_mesh -> texture_mesh:   pointer  "'Use another mesh for texture indices (vertex indices must be aligned)'"
+ID|Mesh.total_edge_sel -> total_edge_sel:   int,  "'(read-only)    Selected edge count in editmode'"
+ID|Mesh.total_face_sel -> total_face_sel:   int,  "'(read-only)    Selected face count in editmode'"
+ID|Mesh.total_vert_sel -> total_vert_sel:   int,  "'(read-only)    Selected vertex count in editmode'"
+ID|Mesh.use_mirror_topology -> use_mirror_topology:   boolean  "'Use topology based mirroring'"
+ID|Mesh.use_mirror_x -> use_mirror_x:   boolean  "'X Axis mirror editing'"
+ID|Mesh.use_paint_mask -> use_paint_mask:   boolean  "'Face selection masking for painting'"
+ID|Mesh.uv_texture_clone -> uv_texture_clone:   pointer  "'UV texture to be used as cloning source'"
+ID|Mesh.uv_texture_clone_index -> uv_texture_clone_index:   int  "'Clone UV texture index'"
+ID|Mesh.uv_texture_stencil -> uv_texture_stencil:   pointer  "'UV texture to mask the painted area'"
+ID|Mesh.uv_texture_stencil_index -> uv_texture_stencil_index:   int  "'Mask UV texture index'"
+ID|Mesh.uv_textures -> uv_textures:   collection,  "'(read-only)'"
+ID|Mesh.vertex_colors -> vertex_colors:   collection,  "'(read-only)'"
+ID|Mesh.verts -> verts:   collection,  "'(read-only)    Vertices of the mesh'"
+ID|MetaBall.active_element -> active_element:   pointer,  "'(read-only)    Last selected element'"
+ID|MetaBall.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
+ID|MetaBall.auto_texspace -> use_auto_texspace:   boolean  '"Adjusts active object\'s texture space automatically when transforming object"'
+ID|MetaBall.elements -> elements:   collection,  "'(read-only)    Meta elements'"
+ID|MetaBall.flag -> flag:   enum  "'Metaball edit update behavior'"
+ID|MetaBall.materials -> materials:   collection,  "'(read-only)'"
+ID|MetaBall.render_size -> render_size:   float  "'Polygonization resolution in rendering'"
+ID|MetaBall.texspace_loc -> texspace_loc:   float  "'Texture space location'"
+ID|MetaBall.texspace_size -> texspace_size:   float  "'Texture space size'"
+ID|MetaBall.threshold -> threshold:   float  "'Influence of meta elements'"
+ID|MetaBall.wire_size -> wire_size:   float  "'Polygonization resolution in the 3D viewport'"
+ID|NodeTree.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
+ID|NodeTree.grease_pencil -> grease_pencil:   pointer  "'Grease Pencil datablock'"
+ID|NodeTree.nodes -> nodes:   collection,  "'(read-only)'"
+ID|Object.active_material -> active_material:   pointer  "'Active material being displayed'"
+ID|Object.active_material_index -> active_material_index:   int  "'Index of active material slot'"
+ID|Object.active_particle_system -> active_particle_system:   pointer,  "'(read-only)    Active particle system being displayed'"
+ID|Object.active_particle_system_index -> active_particle_system_index:   int  "'Index of active particle system slot'"
+ID|Object.active_shape_key -> active_shape_key:   pointer,  "'(read-only)    Current shape key'"
+ID|Object.active_shape_key_index -> active_shape_key_index:   int  "'Current shape key index'"
+ID|Object.active_vertex_group -> active_vertex_group:   pointer,  "'(read-only)    Vertex groups of the object'"
+ID|Object.active_vertex_group_index -> active_vertex_group_index:   int  "'Active index in vertex group array'"
+ID|Object.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
+ID|Object.animation_visualisation -> animation_visualisation:   pointer,  "'(read-only)    Animation data for this datablock'"
+ID|Object.bound_box -> bound_box:   float,  "'(read-only)    Objects bound box in object-space coordinates'"
+ID|Object.collision -> collision:   pointer,  "'(read-only)    Settings for using the objects as a collider in physics simulation'"
+ID|Object.color -> color:   float  "'Object color and alpha, used when faces have the ObColor mode enabled'"
+ID|Object.constraints -> constraints:   collection,  "'(read-only)    Constraints affecting the transformation of the object'"
+ID|Object.data -> data:   pointer  "'Object data'"
+ID|Object.delta_location -> delta_location:   float  "'Extra translation added to the location of the object'"
+ID|Object.delta_rotation_euler -> delta_rotation_euler:   float  "'Extra rotation added to the rotation of the object (when using Euler rotations)'"
+ID|Object.delta_rotation_quaternion -> delta_rotation_quaternion:   float  "'Extra rotation added to the rotation of the object (when using Quaternion rotations)'"
+ID|Object.delta_scale -> delta_scale:   float  "'Extra scaling added to the scale of the object'"
+ID|Object.dimensions -> dimensions:   float  "'Absolute bounding box dimensions of the object'"
+ID|Object.draw_axis -> show_axis:   boolean  '"Displays the object\'s origin and axis"'
+ID|Object.draw_bounds -> show_bounds:   boolean  '"Displays the object\'s bounds"'
+ID|Object.draw_bounds_type -> draw_bounds_type:   enum  "'Object boundary display type'"
+ID|Object.draw_name -> show_name:   boolean  '"Displays the object\'s name"'
+ID|Object.draw_texture_space -> show_texture_space:   boolean  '"Displays the object\'s texture space"'
+ID|Object.draw_transparent -> show_transparent:   boolean  "'Enables transparent materials for the object (Mesh only)'"
+ID|Object.draw_wire -> show_wire:   boolean  '"Adds the object\'s wireframe over solid drawing"'
+ID|Object.dupli_faces_scale -> dupli_faces_scale:   float  "'Scale the DupliFace objects'"
+ID|Object.dupli_frames_end -> dupli_frames_end:   int  "'End frame for DupliFrames'"
+ID|Object.dupli_frames_off -> dupli_frames_off:   int  "'Recurring frames to exclude from the Dupliframes'"
+ID|Object.dupli_frames_on -> dupli_frames_on:   int  "'Number of frames to use between DupOff frames'"
+ID|Object.dupli_frames_start -> dupli_frames_start:   int  "'Start frame for DupliFrames'"
+ID|Object.dupli_group -> dupli_group:   pointer  "'Instance an existing group'"
+ID|Object.dupli_list -> dupli_list:   collection,  "'(read-only)    Object duplis'"
+ID|Object.dupli_type -> dupli_type:   enum  "'If not None, object duplication method to use'"
+ID|Object.duplis_used -> is_duplicator:   boolean,  "'(read-only)'"
+ID|Object.empty_draw_size -> empty_draw_size:   float  "'Size of display for empties in the viewport'"
+ID|Object.empty_draw_type -> empty_draw_type:   enum  "'Viewport display style for empties'"
+ID|Object.field -> field:   pointer,  "'(read-only)    Settings for using the objects as a field in physics simulation'"
+ID|Object.game -> game:   pointer,  "'(read-only)    Game engine related settings for the object'"
+ID|Object.grease_pencil -> grease_pencil:   pointer  "'Grease Pencil datablock'"
+ID|Object.hide -> hide:   boolean  "'Restrict visibility in the viewport'"
+ID|Object.hide_render -> hide_render:   boolean  "'Restrict renderability'"
+ID|Object.hide_select -> hide_select:   boolean  "'Restrict selection in the viewport'"
+ID|Object.layers -> layers:   boolean  "'Layers the object is on'"
+ID|Object.location -> location:   float  "'Location of the object'"
+ID|Object.lock_location -> lock_location:   boolean  "'Lock editing of location in the interface'"
+ID|Object.lock_rotation -> lock_rotation:   boolean  "'Lock editing of rotation in the interface'"
+ID|Object.lock_rotation_w -> lock_rotation_w:   boolean  '"Lock editing of \'angle\' component of four-component rotations in the interface"'
+ID|Object.lock_rotations_4d -> lock_rotations_4d:   boolean  "'Lock editing of four component rotations by components (instead of as Eulers)'"
+ID|Object.lock_scale -> lock_scale:   boolean  "'Lock editing of scale in the interface'"
+ID|Object.material_slots -> material_slots:   collection,  "'(read-only)    Material slots in the object'"
+ID|Object.matrix_local -> matrix_local:   float  "'Parent relative transformation matrix'"
+ID|Object.matrix_world -> matrix_world:   float  "'Worldspace transformation matrix'"
+ID|Object.max_draw_type -> draw_type:   enum  "'Maximum draw type to display object with in viewport'"
+ID|Object.mode -> mode:   enum,  "'(read-only)    Object interaction mode'"
+ID|Object.modifiers -> modifiers:   collection,  "'(read-only)    Modifiers affecting the geometric data of the object'"
+ID|Object.motion_path -> motion_path:   pointer,  "'(read-only)    Motion Path for this element'"
+ID|Object.parent -> parent:   pointer  "'Parent Object'"
+ID|Object.parent_bone -> parent_bone:   string  "'Name of parent bone in case of a bone parenting relation'"
+ID|Object.parent_type -> parent_type:   enum  "'Type of parent relation'"
+ID|Object.parent_vertices -> parent_vertices:   int,  "'(read-only)    Indices of vertices in cases of a vertex parenting relation'"
+ID|Object.particle_systems -> particle_systems:   collection,  "'(read-only)    Particle systems emitted from the object'"
+ID|Object.pass_index -> pass_index:   int  "'Index # for the IndexOB render pass'"
+ID|Object.pose -> pose:   pointer,  "'(read-only)    Current pose for armatures'"
+ID|Object.pose_library -> pose_library:   pointer,  "'(read-only)    Action used as a pose library for armatures'"
+ID|Object.proxy -> proxy:   pointer,  "'(read-only)    Library object this proxy object controls'"
+ID|Object.proxy_group -> proxy_group:   pointer,  "'(read-only)    Library group duplicator object this proxy object controls'"
+ID|Object.rotation_axis_angle -> rotation_axis_angle:   float  "'Angle of Rotation for Axis-Angle rotation representation'"
+ID|Object.rotation_euler -> rotation_euler:   float  "'Rotation in Eulers'"
+ID|Object.rotation_mode -> rotation_mode:   enum  "'NO DESCRIPTION'"
+ID|Object.rotation_quaternion -> rotation_quaternion:   float  "'Rotation in Quaternions'"
+ID|Object.scale -> scale:   float  "'Scaling of the object'"
+ID|Object.select -> select:   boolean  "'Object selection state'"
+ID|Object.shape_key_edit_mode -> use_shape_key_edit_mode:   boolean  "'Apply shape keys in edit mode (for Meshes only)'"
+ID|Object.shape_key_lock -> show_shape_key:   boolean  "'Always show the current Shape for this Object'"
+ID|Object.slow_parent -> use_slow_parent:   boolean  "'Create a delay in the parent relationship'"
+ID|Object.soft_body -> soft_body:   pointer,  "'(read-only)    Settings for soft body simulation'"
+ID|Object.time_offset -> time_offset:   float  "'Animation offset in frames for F-Curve and dupligroup instances'"
+ID|Object.time_offset_add_parent -> use_time_offset_add_parent:   boolean  "'Add the parents time offset value'"
+ID|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'"
+ID|Object.time_offset_parent -> use_time_offset_parent:   boolean  "'Apply the time offset to this objects parent relationship'"
+ID|Object.time_offset_particle -> use_time_offset_particle:   boolean  "'Let the time offset work on the particle effect'"
+ID|Object.track_axis -> track_axis:   enum  '"Axis that points in \'forward\' direction"'
+ID|Object.type -> type:   enum,  "'(read-only)    Type of Object'"
+ID|Object.up_axis -> up_axis:   enum  "'Axis that points in the upward direction'"
+ID|Object.use_dupli_faces_scale -> use_dupli_faces_scale:   boolean  "'Scale dupli based on face size'"
+ID|Object.use_dupli_frames_speed -> use_dupli_frames_speed:   boolean  "'Set dupliframes to use the frame'"
+ID|Object.use_dupli_verts_rotation -> use_dupli_verts_rotation:   boolean  "'Rotate dupli according to vertex normal'"
+ID|Object.vertex_groups -> vertex_groups:   collection,  "'(read-only)    Vertex groups of the object'"
+ID|Object.x_ray -> show_x_ray:   boolean  "'Makes the object draw in front of others'"
+ID|ParticleSettings.abs_path_time -> use_absolute_path_time:   boolean  "'Path timing is in absolute frames'"
+ID|ParticleSettings.active_dupliweight -> active_dupliweight:   pointer,  "'(read-only)'"
+ID|ParticleSettings.active_dupliweight_index -> active_dupliweight_index:   int  "'NO DESCRIPTION'"
+ID|ParticleSettings.adaptive_angle -> adaptive_angle:   int  "'How many degrees path has to curve to make another render segment'"
+ID|ParticleSettings.adaptive_pix -> adaptive_pix:   int  "'How many pixels path has to cover to make another render segment'"
+ID|ParticleSettings.amount -> amount:   int  "'Total number of particles'"
+ID|ParticleSettings.angular_velocity_factor -> angular_velocity_factor:   float  "'Angular velocity amount'"
+ID|ParticleSettings.angular_velocity_mode -> angular_velocity_mode:   enum  "'Particle angular velocity mode'"
+ID|ParticleSettings.animate_branching -> use_animate_branching:   boolean  "'Animate branching'"
+ID|ParticleSettings.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
+ID|ParticleSettings.billboard_align -> billboard_align:   enum  "'In respect to what the billboards are aligned'"
+ID|ParticleSettings.billboard_animation -> billboard_animation:   enum  "'How to animate billboard textures'"
+ID|ParticleSettings.billboard_lock -> lock_billboard:   boolean  "'Lock the billboards align axis'"
+ID|ParticleSettings.billboard_object -> billboard_object:   pointer  "'Billboards face this object (default is active camera)'"
+ID|ParticleSettings.billboard_offset -> billboard_offset:   float  "'NO DESCRIPTION'"
+ID|ParticleSettings.billboard_random_tilt -> billboard_random_tilt:   float  "'Random tilt of the billboards'"
+ID|ParticleSettings.billboard_split_offset -> billboard_split_offset:   enum  "'How to offset billboard textures'"
+ID|ParticleSettings.billboard_tilt -> billboard_tilt:   float  "'Tilt of the billboards'"
+ID|ParticleSettings.billboard_uv_split -> billboard_uv_split:   int  "'Amount of rows/columns to split UV coordinates for billboards'"
+ID|ParticleSettings.boids -> boids:   pointer,  "'(read-only)'"
+ID|ParticleSettings.boids_2d -> lock_boids_to_surface:   boolean  "'Constrain boids to a surface'"
+ID|ParticleSettings.branch_threshold -> branch_threshold:   float  "'Threshold of branching'"
+ID|ParticleSettings.branching -> use_branching:   boolean  "'Branch child paths from each other'"
+ID|ParticleSettings.brownian_factor -> brownian_factor:   float  "'Specify the amount of Brownian motion'"
+ID|ParticleSettings.child_effector -> apply_effector_to_children:   boolean  "'Apply effectors to children'"
+ID|ParticleSettings.child_guide -> apply_guide_to_children:   boolean  "'NO DESCRIPTION'"
+ID|ParticleSettings.child_length -> child_length:   float  "'Length of child paths'"
+ID|ParticleSettings.child_length_thres -> child_length_thres:   float  "'Amount of particles left untouched by child path length'"
+ID|ParticleSettings.child_nbr -> child_nbr:   int  "'Amount of children/parent'"
+ID|ParticleSettings.child_radius -> child_radius:   float  "'Radius of children around parent'"
+ID|ParticleSettings.child_random_size -> child_random_size:   float  "'Random variation to the size of the child particles'"
+ID|ParticleSettings.child_roundness -> child_roundness:   float  "'Roundness of children around parent'"
+ID|ParticleSettings.child_size -> child_size:   float  "'A multiplier for the child particle size'"
+ID|ParticleSettings.child_type -> child_type:   enum  "'Create child particles'"
+ID|ParticleSettings.clump_factor -> clump_factor:   float  "'Amount of clumping'"
+ID|ParticleSettings.clumppow -> clumppow:   float  "'Shape of clumping'"
+ID|ParticleSettings.damp_factor -> damp_factor:   float  "'Specify the amount of damping'"
+ID|ParticleSettings.die_on_collision -> use_die_on_collision:   boolean  "'Particles die when they collide with a deflector object'"
+ID|ParticleSettings.died -> use_died:   boolean  "'Show particles after they have died'"
+ID|ParticleSettings.display -> display:   int  "'Percentage of particles to display in 3D view'"
+ID|ParticleSettings.distribution -> distribution:   enum  "'How to distribute particles on selected element'"
+ID|ParticleSettings.drag_factor -> drag_factor:   float  "'Specify the amount of air-drag'"
+ID|ParticleSettings.draw_as -> draw_as:   enum  "'How particles are drawn in viewport'"
+ID|ParticleSettings.draw_health -> show_health:   boolean  "'Draw boid health'"
+ID|ParticleSettings.draw_size -> draw_size:   int  "'Size of particles on viewport in pixels (0=default)'"
+ID|ParticleSettings.draw_step -> draw_step:   int  "'How many steps paths are drawn with (power of 2)'"
+ID|ParticleSettings.dupli_group -> dupli_group:   pointer  "'Show Objects in this Group in place of particles'"
+ID|ParticleSettings.dupli_object -> dupli_object:   pointer  "'Show this Object in place of particles'"
+ID|ParticleSettings.dupliweights -> dupliweights:   collection,  "'(read-only)    Weights for all of the objects in the dupli group'"
+ID|ParticleSettings.effect_hair -> effect_hair:   float  "'Hair stiffness for effectors'"
+ID|ParticleSettings.effector_weights -> effector_weights:   pointer,  "'(read-only)'"
+ID|ParticleSettings.emit_from -> emit_from:   enum  "'Where to emit particles from'"
+ID|ParticleSettings.emitter -> use_render_emitter:   boolean  "'Render emitter Object also'"
+ID|ParticleSettings.enable_simplify -> use_simplify:   boolean  "'Remove child strands as the object becomes smaller on the screen'"
+ID|ParticleSettings.even_distribution -> use_even_distribution:   boolean  "'Use even distribution from faces based on face areas or edge lengths'"
+ID|ParticleSettings.fluid -> fluid:   pointer,  "'(read-only)'"
+ID|ParticleSettings.force_field_1 -> force_field_1:   pointer,  "'(read-only)'"
+ID|ParticleSettings.force_field_2 -> force_field_2:   pointer,  "'(read-only)'"
+ID|ParticleSettings.frame_end -> frame_end:   float  "'Frame # to stop emitting particles'"
+ID|ParticleSettings.frame_start -> frame_start:   float  "'Frame # to start emitting particles'"
+ID|ParticleSettings.grid_invert -> invert_grid:   boolean  "'Invert what is considered object and what is not'"
+ID|ParticleSettings.grid_resolution -> grid_resolution:   int  "'The resolution of the particle grid'"
+ID|ParticleSettings.hair_bspline -> use_hair_bspline:   boolean  "'Interpolate hair using B-Splines'"
+ID|ParticleSettings.hair_step -> hair_step:   int  "'Number of hair segments'"
+ID|ParticleSettings.integrator -> integrator:   enum  "'Select physics integrator type'"
+ID|ParticleSettings.jitter_factor -> jitter_factor:   float  "'Amount of jitter applied to the sampling'"
+ID|ParticleSettings.keyed_loops -> keyed_loops:   int  "'Number of times the keys are looped'"
+ID|ParticleSettings.keys_step -> keys_step:   int  "'NO DESCRIPTION'"
+ID|ParticleSettings.kink -> kink:   enum  "'Type of periodic offset on the path'"
+ID|ParticleSettings.kink_amplitude -> kink_amplitude:   float  "'The amplitude of the offset'"
+ID|ParticleSettings.kink_axis -> kink_axis:   enum  "'Which axis to use for offset'"
+ID|ParticleSettings.kink_frequency -> kink_frequency:   float  "'The frequency of the offset (1/total length)'"
+ID|ParticleSettings.kink_shape -> kink_shape:   float  "'Adjust the offset to the beginning/end'"
+ID|ParticleSettings.lifetime -> lifetime:   float  "'Specify the life span of the particles'"
+ID|ParticleSettings.line_length_head -> line_length_head:   float  '"Length of the line\'s head"'
+ID|ParticleSettings.line_length_tail -> line_length_tail:   float  '"Length of the line\'s tail"'
+ID|ParticleSettings.mass -> mass:   float  "'Specify the mass of the particles'"
+ID|ParticleSettings.material -> material:   int  "'Specify material used for the particles'"
+ID|ParticleSettings.material_color -> show_material_color:   boolean  '"Draw particles using material\'s diffuse color"'
+ID|ParticleSettings.normal_factor -> normal_factor:   float  "'Let the surface normal give the particle a starting speed'"
+ID|ParticleSettings.num -> show_number:   boolean  "'Show particle number'"
+ID|ParticleSettings.object_aligned_factor -> object_aligned_factor:   float  "'Let the emitter object orientation give the particle a starting speed'"
+ID|ParticleSettings.object_factor -> object_factor:   float  "'Let the object give the particle a starting speed'"
+ID|ParticleSettings.parent -> use_parents:   boolean  "'Render parent particles'"
+ID|ParticleSettings.particle_factor -> particle_factor:   float  "'Let the target particle give the particle a starting speed'"
+ID|ParticleSettings.particle_size -> particle_size:   float  "'The size of the particles'"
+ID|ParticleSettings.path_end -> path_end:   float  "'End time of drawn path'"
+ID|ParticleSettings.path_start -> path_start:   float  "'Starting time of drawn path'"
+ID|ParticleSettings.phase_factor -> phase_factor:   float  "'Initial rotation phase'"
+ID|ParticleSettings.physics_type -> physics_type:   enum  "'Particle physics type'"
+ID|ParticleSettings.rand_group -> use_group_pick_random:   boolean  "'Pick objects from group randomly'"
+ID|ParticleSettings.random_factor -> random_factor:   float  "'Give the starting speed a random variation'"
+ID|ParticleSettings.random_length -> random_length:   float  "'Give path length a random variation'"
+ID|ParticleSettings.random_lifetime -> random_lifetime:   float  "'Give the particle life a random variation'"
+ID|ParticleSettings.random_phase_factor -> random_phase_factor:   float  "'Randomize rotation phase'"
+ID|ParticleSettings.random_rotation_factor -> random_rotation_factor:   float  "'Randomize rotation'"
+ID|ParticleSettings.random_size -> random_size:   float  "'Give the particle size a random variation'"
+ID|ParticleSettings.react_event -> react_event:   enum  "'The event of target particles to react on'"
+ID|ParticleSettings.react_multiple -> use_react_multiple:   boolean  "'React multiple times'"
+ID|ParticleSettings.react_start_end -> use_react_start_end:   boolean  "'Give birth to unreacted particles eventually'"
+ID|ParticleSettings.reaction_shape -> reaction_shape:   float  "'Power of reaction strength dependence on distance to target'"
+ID|ParticleSettings.reactor_factor -> reactor_factor:   float  "'Let the vector away from the target particles location give the particle a starting speed'"
+ID|ParticleSettings.ren_as -> ren_as:   enum  "'How particles are rendered'"
+ID|ParticleSettings.render_adaptive -> use_render_adaptive:   boolean  "'Use adapative rendering for paths'"
+ID|ParticleSettings.render_step -> render_step:   int  "'How many steps paths are rendered with (power of 2)'"
+ID|ParticleSettings.render_strand -> use_strand_primitive:   boolean  "'Use the strand primitive for rendering'"
+ID|ParticleSettings.rendered_child_nbr -> rendered_child_nbr:   int  "'Amount of children/parent for rendering'"
+ID|ParticleSettings.rotate_from -> rotate_from:   enum  "'NO DESCRIPTION'"
+ID|ParticleSettings.rotation_dynamic -> use_dynamic_rotation:   boolean  "'Sets rotation to dynamic/constant'"
+ID|ParticleSettings.rotation_mode -> rotation_mode:   enum  "'Particles initial rotation'"
+ID|ParticleSettings.rough1 -> rough1:   float  "'Amount of location dependent rough'"
+ID|ParticleSettings.rough1_size -> rough1_size:   float  "'Size of location dependent rough'"
+ID|ParticleSettings.rough2 -> rough2:   float  "'Amount of random rough'"
+ID|ParticleSettings.rough2_size -> rough2_size:   float  "'Size of random rough'"
+ID|ParticleSettings.rough2_thres -> rough2_thres:   float  "'Amount of particles left untouched by random rough'"
+ID|ParticleSettings.rough_end_shape -> rough_end_shape:   float  "'Shape of end point rough'"
+ID|ParticleSettings.rough_endpoint -> rough_endpoint:   float  "'Amount of end point rough'"
+ID|ParticleSettings.self_effect -> use_self_effect:   boolean  "'Particle effectors effect themselves'"
+ID|ParticleSettings.show_size -> show_size:   boolean  "'Show particle size'"
+ID|ParticleSettings.simplify_rate -> simplify_rate:   float  "'Speed of simplification'"
+ID|ParticleSettings.simplify_refsize -> simplify_refsize:   int  "'Reference size in pixels, after which simplification begins'"
+ID|ParticleSettings.simplify_transition -> simplify_transition:   float  "'Transition period for fading out strands'"
+ID|ParticleSettings.simplify_viewport -> simplify_viewport:   float  "'Speed of Simplification'"
+ID|ParticleSettings.size_deflect -> use_size_deflect:   boolean  '"Use particle\'s size in deflection"'
+ID|ParticleSettings.sizemass -> use_multiply_size_mass:   boolean  "'Multiply mass by particle size'"
+ID|ParticleSettings.subframes -> subframes:   int  "'Subframes to simulate for improved stability and finer granularity simulations'"
+ID|ParticleSettings.symmetric_branching -> use_symmetric_branching:   boolean  "'Start and end points are the same'"
+ID|ParticleSettings.tangent_factor -> tangent_factor:   float  "'Let the surface tangent give the particle a starting speed'"
+ID|ParticleSettings.tangent_phase -> tangent_phase:   float  "'Rotate the surface tangent'"
+ID|ParticleSettings.time_tweak -> time_tweak:   float  "'A multiplier for physics timestep (1.0 means one frame = 1/25 seconds)'"
+ID|ParticleSettings.trail_count -> trail_count:   int  "'Number of trail particles'"
+ID|ParticleSettings.trand -> use_emit_random:   boolean  "'Emit in random order of elements'"
+ID|ParticleSettings.type -> type:   enum  "'NO DESCRIPTION'"
+ID|ParticleSettings.unborn -> use_unborn:   boolean  "'Show particles before they are emitted'"
+ID|ParticleSettings.use_global_dupli -> use_global_dupli:   boolean  '"Use object\'s global coordinates for duplication"'
+ID|ParticleSettings.use_group_count -> use_group_count:   boolean  "'Use object multiple times in the same group'"
+ID|ParticleSettings.userjit -> userjit:   int  "'Emission locations / face (0 = automatic)'"
+ID|ParticleSettings.velocity -> show_velocity:   boolean  "'Show particle velocity'"
+ID|ParticleSettings.velocity_length -> use_velocity_length:   boolean  "'Multiply line length by particle speed'"
+ID|ParticleSettings.viewport -> use_simplify_viewport:   boolean  "'NO DESCRIPTION'"
+ID|ParticleSettings.virtual_parents -> virtual_parents:   float  "'Relative amount of virtual parents'"
+ID|ParticleSettings.whole_group -> use_whole_group:   boolean  "'Use whole group at once'"
+ID|Scene.active_keying_set -> active_keying_set:   pointer  "'Active Keying Set used to insert/delete keyframes'"
+ID|Scene.active_keying_set_index -> active_keying_set_index:   int  '"Current Keying Set index (negative for \'builtin\' and positive for \'absolute\')"'
+ID|Scene.all_keying_sets -> all_keying_sets:   collection,  "'(read-only)    All Keying Sets available for use (builtins and Absolute Keying Sets for this Scene)'"
+ID|Scene.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
+ID|Scene.bases -> bases:   collection,  "'(read-only)'"
+ID|Scene.camera -> camera:   pointer  "'Active camera used for rendering the scene'"
+ID|Scene.cursor_location -> cursor_location:   float  "'3D cursor location'"
+ID|Scene.distance_model -> distance_model:   enum  "'Distance model for distance attenuation calculation'"
+ID|Scene.doppler_factor -> doppler_factor:   float  "'Pitch factor for Doppler effect calculation'"
+ID|Scene.frame_current -> frame_current:   int  "'NO DESCRIPTION'"
+ID|Scene.frame_drop -> use_frame_drop:   boolean  "'Play back dropping frames if frame display is too slow'"
+ID|Scene.frame_end -> frame_end:   int  "'Final frame of the playback/rendering range'"
+ID|Scene.frame_start -> frame_start:   int  "'First frame of the playback/rendering range'"
+ID|Scene.frame_step -> frame_step:   int  "'Number of frames to skip forward while rendering/playing back each frame'"
+ID|Scene.game_data -> game_data:   pointer,  "'(read-only)'"
+ID|Scene.gravity -> gravity:   float  "'Constant acceleration in a given direction'"
+ID|Scene.grease_pencil -> grease_pencil:   pointer  "'Grease Pencil datablock'"
+ID|Scene.keying_sets -> keying_sets:   collection,  "'(read-only)    Absolute Keying Sets for this Scene'"
+ID|Scene.layers -> layers:   boolean  "'Layers visible when rendering the scene'"
+ID|Scene.mute_audio -> mute_audio:   boolean  "'Play back of audio from Sequence Editor will be muted'"
+ID|Scene.network_render -> network_render:   pointer,  "'(read-only)    Network Render Settings'"
+ID|Scene.nla_tweakmode_on -> use_nla_tweakmode:   boolean,  "'(read-only)    Indicates whether there is any action referenced by NLA being edited. Strictly read-only'"
+ID|Scene.nodetree -> nodetree:   pointer,  "'(read-only)    Compositing node tree'"
+ID|Scene.objects -> objects:   collection,  "'(read-only)'"
+ID|Scene.orientations -> orientations:   collection,  "'(read-only)'"
+ID|Scene.pose_templates -> pose_templates:   pointer,  "'(read-only)    Pose Template Settings'"
+ID|Scene.preview_range_frame_end -> preview_range_frame_end:   int  "'Alternative end frame for UI playback'"
+ID|Scene.preview_range_frame_start -> preview_range_frame_start:   int  "'Alternative start frame for UI playback'"
+ID|Scene.render -> render:   pointer,  "'(read-only)'"
+ID|Scene.scrub_audio -> use_audio_scrub:   boolean  "'Play audio from Sequence Editor while scrubbing'"
+ID|Scene.sequence_editor -> sequence_editor:   pointer,  "'(read-only)'"
+ID|Scene.set -> set:   pointer  "'Background set scene'"
+ID|Scene.speed_of_sound -> speed_of_sound:   float  "'Speed of sound for Doppler effect calculation'"
+ID|Scene.stamp_note -> stamp_note:   string  "'User define note for the render stamping'"
+ID|Scene.sync_audio -> use_audio_sync:   boolean  "'Play back and sync with audio clock, dropping frames if frame display is too slow'"
+ID|Scene.sync_mode -> sync_mode:   enum  "'How to sync playback'"
+ID|Scene.timeline_markers -> timeline_markers:   collection,  "'(read-only)    Markers used in all timelines for the current scene'"
+ID|Scene.tool_settings -> tool_settings:   pointer,  "'(read-only)'"
+ID|Scene.unit_settings -> unit_settings:   pointer,  "'(read-only)    Unit editing settings'"
+ID|Scene.use_gravity -> use_gravity:   boolean  "'Use global gravity for all dynamics'"
+ID|Scene.use_nodes -> use_nodes:   boolean  "'Enable the compositing node tree'"
+ID|Scene.use_preview_range -> use_preview_range:   boolean  "'Use an alternative start/end frame for UI playback, rather than the scene start/end frame'"
+ID|Scene.world -> world:   pointer  "'World used for rendering the scene'"
+ID|Screen.animation_playing -> is_animation_playing:   boolean,  "'(read-only)    Animation playback is active'"
+ID|Screen.areas -> areas:   collection,  "'(read-only)    Areas the screen is subdivided into'"
+ID|Screen.fullscreen -> is_fullscreen:   boolean,  "'(read-only)    An area is maximised, filling this screen'"
+ID|Screen.scene -> scene:   pointer  "'Active scene to be edited in the screen'"
+ID|Sound.caching -> use_ram_cache:   boolean  "'The sound file is decoded and loaded into RAM'"
+ID|Sound.filepath -> filepath:   string  "'Sound sample file used by this Sound datablock'"
+ID|Sound.packed_file -> packed_file:   pointer,  "'(read-only)'"
+ID|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'"
+ID|Text.current_line -> current_line:   pointer,  "'(read-only)    Current line, and start line of selection if one exists'"
+ID|Text.dirty -> is_dirty:   boolean,  "'(read-only)    Text file has been edited since last save'"
+ID|Text.filepath -> filepath:   string  "'Filename of the text file'"
+ID|Text.lines -> lines:   collection,  "'(read-only)    Lines of text'"
+ID|Text.markers -> markers:   collection,  "'(read-only)    Text markers highlighting part of the text'"
+ID|Text.memory -> is_in_memory:   boolean,  "'(read-only)    Text file is in memory, without a corresponding file on disk'"
+ID|Text.modified -> is_modified:   boolean,  "'(read-only)    Text file on disk is different than the one in memory'"
+ID|Text.selection_end_character -> selection_end_character:   int,  "'(read-only)    Index of character after end of selection in the selection end line'"
+ID|Text.selection_end_line -> selection_end_line:   pointer,  "'(read-only)    End line of selection'"
+ID|Text.tabs_as_spaces -> use_tabs_as_spaces:   boolean  "'Automatically converts all new tabs into spaces'"
+ID|Text.use_module -> use_module:   boolean  '"Register this text as a module on loading, Text name must end with \'.py\'"'
+ID|Texture.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
+ID|Texture.brightness -> intensity:   float  "'NO DESCRIPTION'"
+ID|Texture.color_ramp -> color_ramp:   pointer,  "'(read-only)'"
+ID|Texture.contrast -> contrast:   float  "'NO DESCRIPTION'"
+ID|Texture.factor_blue -> factor_blue:   float  "'NO DESCRIPTION'"
+ID|Texture.factor_green -> factor_green:   float  "'NO DESCRIPTION'"
+ID|Texture.factor_red -> factor_red:   float  "'NO DESCRIPTION'"
+ID|Texture.node_tree -> node_tree:   pointer,  "'(read-only)    Node tree for node-based textures'"
+ID|Texture.saturation -> saturation:   float  "'NO DESCRIPTION'"
+ID|Texture.type -> type:   enum  "'NO DESCRIPTION'"
+ID|Texture.use_color_ramp -> use_color_ramp:   boolean  "'Toggle color ramp operations'"
+ID|Texture.use_nodes -> use_nodes:   boolean  "'Make this a node-based texture'"
+ID|Texture.use_preview_alpha -> use_preview_alpha:   boolean  "'Show Alpha in Preview Render'"
++ * ID|Texture|BlendTexture.flip_axis -> flip_axis:   enum  '"Flips the texture\'s X and Y axis"'
++ * ID|Texture|BlendTexture.progression -> progression:   enum  "'Sets the style of the color blending'"
++ * ID|Texture|CloudsTexture.nabla -> nabla:   float  "'Size of derivative offset used for calculating normal'"
++ * ID|Texture|CloudsTexture.noise_basis -> noise_basis:   enum  "'Sets the noise basis used for turbulence'"
++ * ID|Texture|CloudsTexture.noise_depth -> noise_depth:   int  "'Sets the depth of the cloud calculation'"
++ * ID|Texture|CloudsTexture.noise_size -> noise_size:   float  "'Sets scaling for noise input'"
++ * ID|Texture|CloudsTexture.noise_type -> noise_type:   enum  "'NO DESCRIPTION'"
+ID|Texture|CloudsTexture.stype -> stype:   enum  'NO DESCRIPTION'
+ID|Texture|DistortedNoiseTexture.distortion -> distortion:   float  "'NO DESCRIPTION'"
+ID|Texture|DistortedNoiseTexture.nabla -> nabla:   float  "'Size of derivative offset used for calculating normal'"
+ID|Texture|DistortedNoiseTexture.noise_basis -> noise_basis:   enum  "'Sets the noise basis used for turbulence'"
+ID|Texture|DistortedNoiseTexture.noise_distortion -> noise_distortion:   enum  "'Sets the noise basis for the distortion'"
+ID|Texture|DistortedNoiseTexture.noise_size -> noise_size:   float  "'Sets scaling for noise input'"
+ID|Texture|EnvironmentMapTexture.environment_map -> environment_map:   pointer,  "'(read-only)    Gets the environment map associated with this texture'"
+ID|Texture|EnvironmentMapTexture.filter -> filter:   enum  "'Texture filter to use for sampling image'"
+ID|Texture|EnvironmentMapTexture.filter_eccentricity -> filter_eccentricity:   int  "'Maximum eccentricity. Higher gives less blur at distant/oblique angles, but is also slower'"
+ID|Texture|EnvironmentMapTexture.filter_probes -> filter_probes:   int  "'Maximum number of samples. Higher gives less blur at distant/oblique angles, but is also slower'"
+ID|Texture|EnvironmentMapTexture.filter_size -> filter_size:   float  "'Multiplies the filter size used by MIP Map and Interpolation'"
+ID|Texture|EnvironmentMapTexture.filter_size_minimum -> use_filter_size_min:   boolean  "'Use Filter Size as a minimal filter value in pixels'"
+ID|Texture|EnvironmentMapTexture.image -> image:   pointer  "'Source image file to read the environment map from'"
+ID|Texture|EnvironmentMapTexture.image_user -> image_user:   pointer,  "'(read-only)    Parameters defining which layer, pass and frame of the image is displayed'"
+ID|Texture|EnvironmentMapTexture.mipmap -> use_mipmap:   boolean  "'Uses auto-generated MIP maps for the image'"
+ID|Texture|EnvironmentMapTexture.mipmap_gauss -> use_mipmap_gauss:   boolean  "'Uses Gauss filter to sample down MIP maps'"
+ID|Texture|ImageTexture.calculate_alpha -> use_calculate_alpha:   boolean  "'Calculates an alpha channel based on RGB values in the image'"
+ID|Texture|ImageTexture.checker_distance -> checker_distance:   float  "'Sets distance between checker tiles'"
+ID|Texture|ImageTexture.checker_even -> use_checker_even:   boolean  "'Sets even checker tiles'"
+ID|Texture|ImageTexture.checker_odd -> use_checker_odd:   boolean  "'Sets odd checker tiles'"
+ID|Texture|ImageTexture.crop_max_x -> crop_max_x:   float  "'Sets maximum X value to crop the image'"
+ID|Texture|ImageTexture.crop_max_y -> crop_max_y:   float  "'Sets maximum Y value to crop the image'"
+ID|Texture|ImageTexture.crop_min_x -> crop_min_x:   float  "'Sets minimum X value to crop the image'"
+ID|Texture|ImageTexture.crop_min_y -> crop_min_y:   float  "'Sets minimum Y value to crop the image'"
+ID|Texture|ImageTexture.extension -> extension:   enum  "'Sets how the image is extrapolated past its original bounds'"
+ID|Texture|ImageTexture.filter -> filter:   enum  "'Texture filter to use for sampling image'"
+ID|Texture|ImageTexture.filter_eccentricity -> filter_eccentricity:   int  "'Maximum eccentricity. Higher gives less blur at distant/oblique angles, but is also slower'"
+ID|Texture|ImageTexture.filter_probes -> filter_probes:   int  "'Maximum number of samples. Higher gives less blur at distant/oblique angles, but is also slower'"
+ID|Texture|ImageTexture.filter_size -> filter_size:   float  "'Multiplies the filter size used by MIP Map and Interpolation'"
+ID|Texture|ImageTexture.filter_size_minimum -> use_minimum_filter_size:   boolean  "'Use Filter Size as a minimal filter value in pixels'"
+ID|Texture|ImageTexture.flip_axis -> use_flip_axis:   boolean  '"Flips the texture\'s X and Y axis"'
+ID|Texture|ImageTexture.image -> image:   pointer  "'NO DESCRIPTION'"
+ID|Texture|ImageTexture.image_user -> image_user:   pointer,  "'(read-only)    Parameters defining which layer, pass and frame of the image is displayed'"
+ID|Texture|ImageTexture.interpolation -> use_interpolation:   boolean  "'Interpolates pixels using Area filter'"
+ID|Texture|ImageTexture.invert_alpha -> invert_alpha:   boolean  "'Inverts all the alpha values in the image'"
+ID|Texture|ImageTexture.mipmap -> use_mipmap:   boolean  "'Uses auto-generated MIP maps for the image'"
+ID|Texture|ImageTexture.mipmap_gauss -> use_mipmap_gauss:   boolean  "'Uses Gauss filter to sample down MIP maps'"
+ID|Texture|ImageTexture.mirror_x -> use_mirror_x:   boolean  "'Mirrors the image repetition on the X direction'"
+ID|Texture|ImageTexture.mirror_y -> use_mirror_y:   boolean  "'Mirrors the image repetition on the Y direction'"
+ID|Texture|ImageTexture.normal_map -> use_normal_map:   boolean  "'Uses image RGB values for normal mapping'"
+ID|Texture|ImageTexture.normal_space -> normal_space:   enum  "'Sets space of normal map image'"
+ID|Texture|ImageTexture.repeat_x -> repeat_x:   int  "'Sets a repetition multiplier in the X direction'"
+ID|Texture|ImageTexture.repeat_y -> repeat_y:   int  "'Sets a repetition multiplier in the Y direction'"
+ID|Texture|ImageTexture.use_alpha -> use_alpha:   boolean  "'Uses the alpha channel information in the image'"
+ID|Texture|MagicTexture.noise_depth -> noise_depth:   int  "'Sets the depth of the cloud calculation'"
+ID|Texture|MagicTexture.turbulence -> turbulence:   float  "'Sets the turbulence of the bandnoise and ringnoise types'"
+ID|Texture|MarbleTexture.nabla -> nabla:   float  "'Size of derivative offset used for calculating normal'"
+ID|Texture|MarbleTexture.noise_basis -> noise_basis:   enum  "'Sets the noise basis used for turbulence'"
+ID|Texture|MarbleTexture.noise_depth -> noise_depth:   int  "'Sets the depth of the cloud calculation'"
+ID|Texture|MarbleTexture.noise_size -> noise_size:   float  "'Sets scaling for noise input'"
+ID|Texture|MarbleTexture.noise_type -> noise_type:   enum  "'NO DESCRIPTION'"
+ID|Texture|MarbleTexture.noisebasis2 -> noisebasis2:   enum  "'NO DESCRIPTION'"
+ID|Texture|MarbleTexture.stype -> stype:   enum  "'NO DESCRIPTION'"
+ID|Texture|MarbleTexture.turbulence -> turbulence:   float  "'Sets the turbulence of the bandnoise and ringnoise types'"
+ID|Texture|MusgraveTexture.gain -> gain:   float  "'The gain multiplier'"
+ID|Texture|MusgraveTexture.highest_dimension -> highest_dimension:   float  "'Highest fractal dimension'"
+ID|Texture|MusgraveTexture.lacunarity -> lacunarity:   float  "'Gap between successive frequencies'"
+ID|Texture|MusgraveTexture.musgrave_type -> musgrave_type:   enum  "'NO DESCRIPTION'"
+ID|Texture|MusgraveTexture.nabla -> nabla:   float  "'Size of derivative offset used for calculating normal'"
+ID|Texture|MusgraveTexture.noise_basis -> noise_basis:   enum  "'Sets the noise basis used for turbulence'"
+ID|Texture|MusgraveTexture.noise_intensity -> noise_intensity:   float  "'NO DESCRIPTION'"
+ID|Texture|MusgraveTexture.noise_size -> noise_size:   float  "'Sets scaling for noise input'"
+ID|Texture|MusgraveTexture.octaves -> octaves:   float  "'Number of frequencies used'"
+ID|Texture|MusgraveTexture.offset -> offset:   float  "'The fractal offset'"
+ID|Texture|PointDensityTexture.pointdensity -> pointdensity:   pointer,  "'(read-only)    The point density settings associated with this texture'"
+ID|Texture|StucciTexture.noise_basis -> noise_basis:   enum  "'Sets the noise basis used for turbulence'"
+ID|Texture|StucciTexture.noise_size -> noise_size:   float  "'Sets scaling for noise input'"
+ID|Texture|StucciTexture.noise_type -> noise_type:   enum  "'NO DESCRIPTION'"
+ID|Texture|StucciTexture.stype -> stype:   enum  "'NO DESCRIPTION'"
+ID|Texture|StucciTexture.turbulence -> turbulence:   float  "'Sets the turbulence of the bandnoise and ringnoise types'"
+ID|Texture|VoronoiTexture.coloring -> color_mode:   enum  "'NO DESCRIPTION'"
+ID|Texture|VoronoiTexture.distance_metric -> distance_metric:   enum  "'NO DESCRIPTION'"
+ID|Texture|VoronoiTexture.minkovsky_exponent -> minkovsky_exponent:   float  "'Minkovsky exponent'"
+ID|Texture|VoronoiTexture.nabla -> nabla:   float  "'Size of derivative offset used for calculating normal'"
+ID|Texture|VoronoiTexture.noise_intensity -> noise_intensity:   float  "'NO DESCRIPTION'"
+ID|Texture|VoronoiTexture.noise_size -> noise_size:   float  "'Sets scaling for noise input'"
+ID|Texture|VoronoiTexture.weight_1 -> weight_1:   float  "'Voronoi feature weight 1'"
+ID|Texture|VoronoiTexture.weight_2 -> weight_2:   float  "'Voronoi feature weight 2'"
+ID|Texture|VoronoiTexture.weight_3 -> weight_3:   float  "'Voronoi feature weight 3'"
+ID|Texture|VoronoiTexture.weight_4 -> weight_4:   float  "'Voronoi feature weight 4'"
+ID|Texture|VoxelDataTexture.image -> image:   pointer  "'NO DESCRIPTION'"
+ID|Texture|VoxelDataTexture.image_user -> image_user:   pointer,  "'(read-only)    Parameters defining which layer, pass and frame of the image is displayed'"
+ID|Texture|VoxelDataTexture.voxeldata -> voxeldata:   pointer,  "'(read-only)    The voxel data associated with this texture'"
+ID|Texture|WoodTexture.nabla -> nabla:   float  "'Size of derivative offset used for calculating normal'"
+ID|Texture|WoodTexture.noise_basis -> noise_basis:   enum  "'Sets the noise basis used for turbulence'"
+ID|Texture|WoodTexture.noise_size -> noise_size:   float  "'Sets scaling for noise input'"
+ID|Texture|WoodTexture.noise_type -> noise_type:   enum  "'NO DESCRIPTION'"
+ID|Texture|WoodTexture.noisebasis2 -> noisebasis2:   enum  "'NO DESCRIPTION'"
+ID|Texture|WoodTexture.stype -> stype:   enum  "'NO DESCRIPTION'"
+ID|Texture|WoodTexture.turbulence -> turbulence:   float  "'Sets the turbulence of the bandnoise and ringnoise types'"
+ID|VectorFont.filepath -> filepath:   string,  "'(read-only)'"
+ID|VectorFont.packed_file -> packed_file:   pointer,  "'(read-only)'"
+ID|WindowManager.active_keyconfig -> active_keyconfig:   pointer  "'NO DESCRIPTION'"
+ID|WindowManager.default_keyconfig -> default_keyconfig:   pointer,  "'(read-only)'"
+ID|WindowManager.keyconfigs -> keyconfigs:   collection,  "'(read-only)    Registered key configurations'"
+ID|WindowManager.operators -> operators:   collection,  "'(read-only)    Operator registry'"
+ID|WindowManager.windows -> windows:   collection,  "'(read-only)    Open windows'"
+ID|World.active_texture -> active_texture:   pointer  "'Active texture slot being displayed'"
+ID|World.active_texture_index -> active_texture_index:   int  "'Index of active texture slot'"
+ID|World.ambient_color -> ambient_color:   float  "'NO DESCRIPTION'"
+ID|World.animation_data -> animation_data:   pointer,  "'(read-only)    Animation data for this datablock'"
+ID|World.blend_sky -> use_sky_blend:   boolean  "'Render background with natural progression from horizon to zenith'"
+ID|World.exposure -> exposure:   float  "'Amount of exponential color correction for light'"
+ID|World.horizon_color -> horizon_color:   float  "'Color at the horizon'"
+ID|World.lighting -> lighting:   pointer,  "'(read-only)    World lighting settings'"
+ID|World.mist -> mist:   pointer,  "'(read-only)    World mist settings'"
+ID|World.paper_sky -> use_sky_paper:   boolean  "'Flatten blend or texture coordinates'"
+ID|World.range -> range:   float  "'The color range that will be mapped to 0-1'"
+ID|World.real_sky -> use_sky_real:   boolean  "'Render background with a real horizon, relative to the camera angle'"
+ID|World.stars -> stars:   pointer,  "'(read-only)    World stars settings'"
+ID|World.texture_slots -> texture_slots:   collection,  "'(read-only)    Texture slots defining the mapping and influence of textures'"
+ID|World.zenith_color -> zenith_color:   float  "'Color at the zenith'"
 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'"
+IKParam|Itasc.auto_step -> use_auto_step:   boolean  "'Automatically determine the optimal number of steps for best performance/accuracy trade off'"
+IKParam|Itasc.dampeps -> dampeps:   float  "'Singular value under which damping is progressively applied. Higher values=more stability, less reactivity. Default=0.1'"
+IKParam|Itasc.dampmax -> dampmax:   float  "'Maximum damping coefficient when singular value is nearly 0. Higher values=more stability, less reactivity. Default=0.5'"
+IKParam|Itasc.feedback -> feedback:   float  "'Feedback coefficient for error correction. Average response time=1/feedback. Default=20'"
+IKParam|Itasc.max_step -> step_max:   float  "'Higher bound for timestep in second in case of automatic substeps'"
+IKParam|Itasc.max_velocity -> velocity_max:   float  "'Maximum joint velocity in rad/s. Default=50'"
+IKParam|Itasc.min_step -> step_min:   float  "'Lower bound for timestep in second in case of automatic substeps'"
+IKParam|Itasc.mode -> mode:   enum  "'NO DESCRIPTION'"
+IKParam|Itasc.num_iter -> num_iter:   int  "'Maximum number of iterations for convergence in case of reiteration'"
+IKParam|Itasc.num_step -> num_step:   int  "'Divides the frame interval into this many steps'"
+IKParam|Itasc.precision -> precision:   float  "'Precision of convergence in case of reiteration'"
+IKParam|Itasc.reiteration -> reiteration:   enum  "'Defines if the solver is allowed to reiterate (converges until precision is met) on none, first or all frames'"
+IKParam|Itasc.solver -> solver:   enum  "'Solving method selection: Automatic damping or manual damping'"
 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)'"
@@ -1339,48 +1939,6 @@ 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'"
@@ -1408,12 +1966,6 @@ KeyMapItem.propvalue -> propvalue:   enum  "'The value this event translates to
 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'"
@@ -1448,42 +2000,6 @@ 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'"
@@ -1500,81 +2016,15 @@ 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.'"
@@ -1604,98 +2054,6 @@ 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'"
@@ -1767,60 +2125,6 @@ MaterialSubsurfaceScattering.ior -> ior:   float  "'Index of refraction (higher
 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'"
@@ -1843,52 +2147,6 @@ MaterialVolume.transmission_color -> transmission_color:   float  "'Result color
 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'"
@@ -1897,12 +2155,6 @@ MeshColorLayer.active -> active:   boolean  "'Sets the layer as active for displ
 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'"
@@ -1968,23 +2220,6 @@ 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'"
@@ -1995,37 +2230,6 @@ MetaElement.size_y -> size_y:   float  "'Size of element, use of components depe
 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'"
@@ -2033,6 +2237,218 @@ Modifier.on_cage -> show_on_cage:   boolean  "'Enable direct editing of modifier
 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)'"
++ * Modifier|ArmatureModifier.invert -> invert_vertex_group:   boolean  "'Invert vertex group influence'"
++ * Modifier|ArmatureModifier.multi_modifier -> use_multi_modifier:   boolean  "'Use same input as previous modifier, and mix results using overall vgroup'"
++ * Modifier|ArmatureModifier.object -> object:   pointer  "'Armature object to deform with'"
++ * Modifier|ArmatureModifier.quaternion -> use_deform_preserve_volume:   boolean  "'Deform rotation interpolation with quaternions'"
++ * Modifier|ArmatureModifier.use_bone_envelopes -> use_bone_envelopes:   boolean  "'NO DESCRIPTION'"
++ * Modifier|ArmatureModifier.use_vertex_groups -> use_vertex_groups:   boolean  "'NO DESCRIPTION'"
++ * Modifier|ArmatureModifier.vertex_group -> vertex_group:   string  "'Vertex group name'"
++ * Modifier|ArrayModifier.add_offset_object -> use_object_offset:   boolean  '"Add another object\'s transformation to the total offset"'
++ * Modifier|ArrayModifier.constant_offset -> use_constant_offset:   boolean  "'Add a constant offset'"
++ * Modifier|ArrayModifier.constant_offset_displacement -> constant_offset_displace:   float  "'NO DESCRIPTION'"
+CHECK WITH SIMILAR * Modifier|ArrayModifier.count -> count:   int  'Number of duplicates to make'
++ * Modifier|ArrayModifier.curve -> curve:   pointer  "'Curve object to fit array length to'"
++ * Modifier|ArrayModifier.end_cap -> end_cap:   pointer  "'Mesh object to use as an end cap'"
++ * Modifier|ArrayModifier.fit_type -> fit_type:   enum  "'Array length calculation method'"
++ * Modifier|ArrayModifier.length -> fit_length:   float  "'Length to fit array within'"
++ * Modifier|ArrayModifier.merge_adjacent_vertices -> use_merge_vertices:   boolean  "'Merge vertices in adjacent duplicates'"
++ * Modifier|ArrayModifier.merge_distance -> merge_threshold:   float  "'Limit below which to merge vertices'"
++ * Modifier|ArrayModifier.merge_end_vertices -> use_merge_vertices_cap:   boolean  "'Merge vertices in first and last duplicates'"
++ * Modifier|ArrayModifier.offset_object -> offset_object:   pointer  "'NO DESCRIPTION'"
++ * Modifier|ArrayModifier.relative_offset -> use_relative_offset:   boolean  '"Add an offset relative to the object\'s bounding box"'
++ * Modifier|ArrayModifier.relative_offset_displacement -> relative_offset_displace:   float  "'NO DESCRIPTION'"
++ * Modifier|ArrayModifier.start_cap -> start_cap:   pointer  "'Mesh object to use as a start cap'"
++ * Modifier|BevelModifier.angle -> angle_limit:   float  "'Angle above which to bevel edges'"
++ * Modifier|BevelModifier.edge_weight_method -> edge_weight_method:   enum  "'What edge weight to use for weighting a vertex'"
++ * Modifier|BevelModifier.limit_method -> limit_method:   enum  "'NO DESCRIPTION'"
++ * Modifier|BevelModifier.only_vertices -> use_only_vertices:   boolean  "'Bevel verts/corners, not edges'"
++ * Modifier|BevelModifier.width -> width:   float  "'Bevel value/amount'"
++ * Modifier|BooleanModifier.object -> object:   pointer  "'Mesh object to use for Boolean operation'"
++ * Modifier|BooleanModifier.operation -> operation:   enum  "'NO DESCRIPTION'"
++ * Modifier|BuildModifier.frame_start -> frame_start:   float  "'Specify the start frame of the effect'"
++ * Modifier|BuildModifier.length -> frame_length:   float  "'Specify the total time the build effect requires'"
++ * Modifier|BuildModifier.randomize -> use_random_order:   boolean  "'Randomize the faces or edges during build'"
++ * Modifier|BuildModifier.seed -> seed:   int  "'Specify the seed for random if used'"
++ * Modifier|CastModifier.cast_type -> cast_type:   enum  "'NO DESCRIPTION'"
++ * Modifier|CastModifier.factor -> factor:   float  "'NO DESCRIPTION'"
++ * Modifier|CastModifier.from_radius -> use_radius_as_size:   boolean  "'Use radius as size of projection shape (0 = auto)'"
++ * Modifier|CastModifier.object -> object:   pointer  "'Control object: if available, its location determines the center of the effect'"
++ * Modifier|CastModifier.radius -> radius:   float  "'Only deform vertices within this distance from the center of the effect (leave as 0 for infinite.)'"
++ * Modifier|CastModifier.size -> size:   float  "'Size of projection shape (leave as 0 for auto.)'"
++ * Modifier|CastModifier.use_transform -> use_transform:   boolean  "'Use object transform to control projection shape'"
++ * Modifier|CastModifier.vertex_group -> vertex_group:   string  "'Vertex group name'"
++ * Modifier|CastModifier.x -> use_x:   boolean  "'NO DESCRIPTION'"
++ * Modifier|CastModifier.y -> use_y:   boolean  "'NO DESCRIPTION'"
++ * Modifier|CastModifier.z -> use_z:   boolean  "'NO DESCRIPTION'"
++ * Modifier|ClothModifier.collision_settings -> collision_settings:   pointer,  "'(read-only)'"
++ * Modifier|ClothModifier.point_cache -> point_cache:   pointer,  "'(read-only)'"
++ * Modifier|ClothModifier.settings -> settings:   pointer,  "'(read-only)'"
++ * Modifier|CollisionModifier.settings -> settings:   pointer,  "'(read-only)'"
+Modifier|CurveModifier.deform_axis -> deform_axis:   enum  "'The axis that the curve deforms along'"
+Modifier|CurveModifier.object -> object:   pointer  "'Curve object to deform with'"
+Modifier|CurveModifier.vertex_group -> vertex_group:   string  "'Vertex group name'"
+Modifier|DecimateModifier.face_count -> face_count:   int,  "'(read-only)    The current number of faces in the decimated mesh'"
+Modifier|DecimateModifier.ratio -> ratio:   float  "'Defines the ratio of triangles to reduce to'"
+Modifier|DisplaceModifier.direction -> direction:   enum  "'NO DESCRIPTION'"
+Modifier|DisplaceModifier.midlevel -> midlevel:   float  "'Material value that gives no displacement'"
+Modifier|DisplaceModifier.strength -> strength:   float  "'NO DESCRIPTION'"
+Modifier|DisplaceModifier.texture -> texture:   pointer  "'NO DESCRIPTION'"
+Modifier|DisplaceModifier.texture_coordinate_object -> texture_coordinate_object:   pointer  "'NO DESCRIPTION'"
+Modifier|DisplaceModifier.texture_coordinates -> texture_coordinates:   enum  "'NO DESCRIPTION'"
+Modifier|DisplaceModifier.uv_layer -> uv_layer:   string  "'UV layer name'"
+Modifier|DisplaceModifier.vertex_group -> vertex_group:   string  "'Vertex group name'"
+Modifier|EdgeSplitModifier.split_angle -> split_angle:   float  "'Angle above which to split edges'"
+Modifier|EdgeSplitModifier.use_edge_angle -> use_edge_angle:   boolean  "'Split edges with high angle between faces'"
+Modifier|EdgeSplitModifier.use_sharp -> use_edge_sharp:   boolean  "'Split edges that are marked as sharp'"
+Modifier|ExplodeModifier.alive -> show_alive:   boolean  "'Show mesh when particles are alive'"
+Modifier|ExplodeModifier.dead -> show_dead:   boolean  "'Show mesh when particles are dead'"
+Modifier|ExplodeModifier.protect -> protect:   float  "'Clean vertex group edges'"
+Modifier|ExplodeModifier.size -> use_size:   boolean  "'Use particle size for the shrapnel'"
+Modifier|ExplodeModifier.split_edges -> use_edge_split:   boolean  "'Split face edges for nicer shrapnel'"
+Modifier|ExplodeModifier.unborn -> show_unborn:   boolean  "'Show mesh when particles are unborn'"
+Modifier|ExplodeModifier.vertex_group -> vertex_group:   string  "'NO DESCRIPTION'"
+Modifier|FluidSimulationModifier.settings -> settings:   pointer,  "'(read-only)    Settings for how this object is used in the fluid simulation'"
+Modifier|HookModifier.falloff -> falloff:   float  "'If not zero, the distance from the hook where influence ends'"
+Modifier|HookModifier.force -> force:   float  "'Relative force of the hook'"
+Modifier|HookModifier.object -> object:   pointer  "'Parent Object for hook, also recalculates and clears offset'"
+Modifier|HookModifier.subtarget -> subtarget:   string  "'Name of Parent Bone for hook (if applicable), also recalculates and clears offset'"
+Modifier|HookModifier.vertex_group -> vertex_group:   string  "'Vertex group name'"
+Modifier|LatticeModifier.object -> object:   pointer  "'Lattice object to deform with'"
+Modifier|LatticeModifier.vertex_group -> vertex_group:   string  "'Vertex group name'"
+Modifier|MaskModifier.armature -> armature:   pointer  "'Armature to use as source of bones to mask'"
+Modifier|MaskModifier.invert -> invert_vertex_group:   boolean  "'Use vertices that are not part of region defined'"
+Modifier|MaskModifier.mode -> mode:   enum  "'NO DESCRIPTION'"
+Modifier|MaskModifier.vertex_group -> vertex_group:   string  "'Vertex group name'"
+Modifier|MeshDeformModifier.dynamic -> use_dynamic_bind:   boolean  "'Recompute binding dynamically on top of other deformers (slower and more memory consuming.)'"
+Modifier|MeshDeformModifier.invert -> invert_vertex_group:   boolean  "'Invert vertex group influence'"
+Modifier|MeshDeformModifier.is_bound -> is_bound:   boolean,  "'(read-only)    Whether geometry has been bound to control cage'"
+Modifier|MeshDeformModifier.object -> object:   pointer  "'Mesh object to deform with'"
+Modifier|MeshDeformModifier.precision -> precision:   int  "'The grid size for binding'"
+Modifier|MeshDeformModifier.vertex_group -> vertex_group:   string  "'Vertex group name'"
+Modifier|MirrorModifier.clip -> use_clip:   boolean  "'Prevents vertices from going through the mirror during transform'"
+Modifier|MirrorModifier.merge_limit -> merge_limit:   float  "'Distance from axis within which mirrored vertices are merged'"
+Modifier|MirrorModifier.mirror_object -> mirror_object:   pointer  "'Object to use as mirror'"
+Modifier|MirrorModifier.mirror_u -> use_mirror_u:   boolean  "'Mirror the U texture coordinate around the 0.5 point'"
+Modifier|MirrorModifier.mirror_v -> use_mirror_v:   boolean  "'Mirror the V texture coordinate around the 0.5 point'"
+Modifier|MirrorModifier.mirror_vertex_groups -> use_mirror_vertex_groups:   boolean  "'Mirror vertex groups (e.g. .R->.L)'"
+Modifier|MirrorModifier.x -> use_x:   boolean  "'Enable X axis mirror'"
+Modifier|MirrorModifier.y -> use_y:   boolean  "'Enable Y axis mirror'"
+Modifier|MirrorModifier.z -> use_z:   boolean  "'Enable Z axis mirror'"
+Modifier|MultiresModifier.external -> is_external:   boolean,  "'(read-only)    Store multires displacements outside the .blend file, to save memory'"
+Modifier|MultiresModifier.filepath -> filepath:   string  "'Path to external displacements file'"
+Modifier|MultiresModifier.levels -> levels:   int  "'Number of subdivisions to use in the viewport'"
+Modifier|MultiresModifier.optimal_display -> show_only_control_edges:   boolean  "'Skip drawing/rendering of interior subdivided edges'"
+Modifier|MultiresModifier.render_levels -> render_levels:   int  "'NO DESCRIPTION'"
+Modifier|MultiresModifier.sculpt_levels -> sculpt_levels:   int  "'Number of subdivisions to use in sculpt mode'"
+Modifier|MultiresModifier.subdivision_type -> subdivision_type:   enum  "'Selects type of subdivision algorithm'"
+Modifier|MultiresModifier.total_levels -> total_levels:   int,  "'(read-only)    Number of subdivisions for which displacements are stored'"
+Modifier|ParticleInstanceModifier.alive -> use_alive:   boolean  "'Show instances when particles are alive'"
+Modifier|ParticleInstanceModifier.axis -> axis:   enum  "'Pole axis for rotation'"
+Modifier|ParticleInstanceModifier.children -> use_children:   boolean  "'Create instances from child particles'"
+Modifier|ParticleInstanceModifier.dead -> use_dead:   boolean  "'Show instances when particles are dead'"
+Modifier|ParticleInstanceModifier.keep_shape -> use_preserve_shape:   boolean  '"Don\'t stretch the object"'
+Modifier|ParticleInstanceModifier.normal -> use_normal:   boolean  "'Create instances from normal particles'"
+Modifier|ParticleInstanceModifier.object -> object:   pointer  "'Object that has the particle system'"
+Modifier|ParticleInstanceModifier.particle_system_number -> particle_system_number:   int  "'NO DESCRIPTION'"
+Modifier|ParticleInstanceModifier.position -> position:   float  "'Position along path'"
+Modifier|ParticleInstanceModifier.random_position -> random_position:   float  "'Randomize position along path'"
+Modifier|ParticleInstanceModifier.size -> use_size:   boolean  "'Use particle size to scale the instances'"
+Modifier|ParticleInstanceModifier.unborn -> use_unborn:   boolean  "'Show instances when particles are unborn'"
+Modifier|ParticleInstanceModifier.use_path -> use_path:   boolean  "'Create instances along particle paths'"
+Modifier|ParticleSystemModifier.particle_system -> particle_system:   pointer,  "'(read-only)    Particle System that this modifier controls'"
+Modifier|ScrewModifier.angle -> angle:   float  "'Angle of revolution'"
+Modifier|ScrewModifier.axis -> axis:   enum  "'Screw axis'"
+Modifier|ScrewModifier.iterations -> iterations:   int  "'Number of times to apply the screw operation'"
+Modifier|ScrewModifier.object -> object:   pointer  "'Object to define the screw axis'"
+Modifier|ScrewModifier.render_steps -> render_steps:   int  "'Number of steps in the revolution'"
+Modifier|ScrewModifier.screw_offset -> screw_offset:   float  "'Offset the revolution along its axis'"
+Modifier|ScrewModifier.steps -> steps:   int  "'Number of steps in the revolution'"
+Modifier|ScrewModifier.use_normal_calculate -> use_normal_calculate:   boolean  "'Calculate the order of edges (needed for meshes, but not curves)'"
+Modifier|ScrewModifier.use_normal_flip -> use_normal_flip:   boolean  "'Flip normals of lathed faces'"
+Modifier|ScrewModifier.use_object_screw_offset -> use_object_screw_offset:   boolean  "'Use the distance between the objects to make a screw'"
+Modifier|ShrinkwrapModifier.auxiliary_target -> auxiliary_target:   pointer  "'Additional mesh target to shrink to'"
+Modifier|ShrinkwrapModifier.cull_back_faces -> use_cull_back_faces:   boolean  "'Stop vertices from projecting to a back face on the target'"
+Modifier|ShrinkwrapModifier.cull_front_faces -> use_cull_front_faces:   boolean  "'Stop vertices from projecting to a front face on the target'"
+Modifier|ShrinkwrapModifier.keep_above_surface -> use_keep_above_surface:   boolean  "'NO DESCRIPTION'"
+Modifier|ShrinkwrapModifier.mode -> mode:   enum  "'NO DESCRIPTION'"
+Modifier|ShrinkwrapModifier.negative -> use_negative_direction:   boolean  "'Allow vertices to move in the negative direction of axis'"
+Modifier|ShrinkwrapModifier.offset -> offset:   float  "'Distance to keep from the target'"
+Modifier|ShrinkwrapModifier.positive -> use_positive_direction:   boolean  "'Allow vertices to move in the positive direction of axis'"
+Modifier|ShrinkwrapModifier.subsurf_levels -> subsurf_levels:   int  '"Number of subdivisions that must be performed before extracting vertices\' positions and normals"'
+Modifier|ShrinkwrapModifier.target -> target:   pointer  "'Mesh target to shrink to'"
+Modifier|ShrinkwrapModifier.vertex_group -> vertex_group:   string  "'Vertex group name'"
+Modifier|ShrinkwrapModifier.x -> use_project_x:   boolean  "'NO DESCRIPTION'"
+Modifier|ShrinkwrapModifier.y -> use_project_y:   boolean  "'NO DESCRIPTION'"
+Modifier|ShrinkwrapModifier.z -> use_project_z:   boolean  "'NO DESCRIPTION'"
+Modifier|SimpleDeformModifier.factor -> factor:   float  "'NO DESCRIPTION'"
+Modifier|SimpleDeformModifier.limits -> limits:   float  "'Lower/Upper limits for deform'"
+Modifier|SimpleDeformModifier.lock_x_axis -> lock_x:   boolean  "'NO DESCRIPTION'"
+Modifier|SimpleDeformModifier.lock_y_axis -> lock_y:   boolean  "'NO DESCRIPTION'"
+Modifier|SimpleDeformModifier.mode -> mode:   enum  "'NO DESCRIPTION'"
+Modifier|SimpleDeformModifier.origin -> origin:   pointer  "'Origin of modifier space coordinates'"
+Modifier|SimpleDeformModifier.relative -> use_relative:   boolean  "'Sets the origin of deform space to be relative to the object'"
+Modifier|SimpleDeformModifier.vertex_group -> vertex_group:   string  "'Vertex group name'"
+Modifier|SmokeModifier.coll_settings -> coll_settings:   pointer,  "'(read-only)'"
+Modifier|SmokeModifier.domain_settings -> domain_settings:   pointer,  "'(read-only)'"
+Modifier|SmokeModifier.flow_settings -> flow_settings:   pointer,  "'(read-only)'"
+Modifier|SmokeModifier.smoke_type -> smoke_type:   enum  "'NO DESCRIPTION'"
+Modifier|SmoothModifier.factor -> factor:   float  "'NO DESCRIPTION'"
+Modifier|SmoothModifier.repeat -> repeat:   int  "'NO DESCRIPTION'"
+Modifier|SmoothModifier.vertex_group -> vertex_group:   string  "'Vertex group name'"
+Modifier|SmoothModifier.x -> use_x:   boolean  "'NO DESCRIPTION'"
+Modifier|SmoothModifier.y -> use_y:   boolean  "'NO DESCRIPTION'"
+Modifier|SmoothModifier.z -> use_z:   boolean  "'NO DESCRIPTION'"
+Modifier|SoftBodyModifier.point_cache -> point_cache:   pointer,  "'(read-only)'"
+Modifier|SoftBodyModifier.settings -> settings:   pointer,  "'(read-only)'"
+Modifier|SolidifyModifier.edge_crease_inner -> edge_crease_inner:   float  "'Assign a crease to inner edges'"
+Modifier|SolidifyModifier.edge_crease_outer -> edge_crease_outer:   float  "'Assign a crease to outer edges'"
+Modifier|SolidifyModifier.edge_crease_rim -> edge_crease_rim:   float  "'Assign a crease to the edges making up the rim'"
+Modifier|SolidifyModifier.invert -> invert_vertex_group:   boolean  "'Invert the vertex group influence'"
+Modifier|SolidifyModifier.offset -> offset:   float  "'NO DESCRIPTION'"
+Modifier|SolidifyModifier.thickness -> thickness:   float  "'Thickness of the shell'"
+Modifier|SolidifyModifier.use_even_offset -> use_even_offset:   boolean  "'Maintain thickness by adjusting for sharp corners (slow, disable when not needed)'"
+Modifier|SolidifyModifier.use_quality_normals -> use_quality_normals:   boolean  "'Calculate normals which result in more even thickness (slow, disable when not needed)'"
+Modifier|SolidifyModifier.use_rim -> use_rim:   boolean  "'Create edge loops between the inner and outer surfaces on face edges (slow, disable when not needed)'"
+Modifier|SolidifyModifier.use_rim_material -> use_rim_material:   boolean  "'Use in the next material for rim faces'"
+Modifier|SolidifyModifier.vertex_group -> vertex_group:   string  "'Vertex group name'"
+Modifier|SubsurfModifier.levels -> levels:   int  "'Number of subdivisions to perform'"
+Modifier|SubsurfModifier.optimal_display -> show_only_control_edges:   boolean  "'Skip drawing/rendering of interior subdivided edges'"
+Modifier|SubsurfModifier.render_levels -> render_levels:   int  "'Number of subdivisions to perform when rendering'"
+Modifier|SubsurfModifier.subdivision_type -> subdivision_type:   enum  "'Selects type of subdivision algorithm'"
+Modifier|SubsurfModifier.subsurf_uv -> use_subsurf_uv:   boolean  "'Use subsurf to subdivide UVs'"
+Modifier|UVProjectModifier.aspect_x -> aspect_x:   float  "'NO DESCRIPTION'"
+Modifier|UVProjectModifier.aspect_y -> aspect_y:   float  "'NO DESCRIPTION'"
+Modifier|UVProjectModifier.image -> image:   pointer  "'NO DESCRIPTION'"
+Modifier|UVProjectModifier.num_projectors -> num_projectors:   int  "'Number of projectors to use'"
+Modifier|UVProjectModifier.override_image -> use_image_override:   boolean  '"Override faces\' current images with the given image"'
+Modifier|UVProjectModifier.projectors -> projectors:   collection,  "'(read-only)'"
+Modifier|UVProjectModifier.scale_x -> scale_x:   float  "'NO DESCRIPTION'"
+Modifier|UVProjectModifier.scale_y -> scale_y:   float  "'NO DESCRIPTION'"
+Modifier|UVProjectModifier.uv_layer -> uv_layer:   string  "'UV layer name'"
+Modifier|WaveModifier.cyclic -> use_cyclic:   boolean  "'Cyclic wave effect'"
+Modifier|WaveModifier.damping_time -> damping_time:   float  "'NO DESCRIPTION'"
+Modifier|WaveModifier.falloff_radius -> falloff_radius:   float  "'NO DESCRIPTION'"
+Modifier|WaveModifier.height -> height:   float  "'NO DESCRIPTION'"
+Modifier|WaveModifier.lifetime -> lifetime:   float  "'NO DESCRIPTION'"
+Modifier|WaveModifier.narrowness -> narrowness:   float  "'NO DESCRIPTION'"
+Modifier|WaveModifier.normals -> use_normal:   boolean  "'Displace along normal'"
+Modifier|WaveModifier.speed -> speed:   float  "'NO DESCRIPTION'"
+Modifier|WaveModifier.start_position_object -> start_position_object:   pointer  "'NO DESCRIPTION'"
+Modifier|WaveModifier.start_position_x -> start_position_x:   float  "'NO DESCRIPTION'"
+Modifier|WaveModifier.start_position_y -> start_position_y:   float  "'NO DESCRIPTION'"
+Modifier|WaveModifier.texture -> texture:   pointer  "'Texture for modulating the wave'"
+Modifier|WaveModifier.texture_coordinates -> texture_coordinates:   enum  "'Texture coordinates used for modulating input'"
+Modifier|WaveModifier.texture_coordinates_object -> texture_coordinates_object:   pointer  "'NO DESCRIPTION'"
+Modifier|WaveModifier.time_offset -> time_offset:   float  "'Either the starting frame (for positive speed) or ending frame (for negative speed.)'"
+Modifier|WaveModifier.uv_layer -> uv_layer:   string  "'UV layer name'"
+Modifier|WaveModifier.vertex_group -> vertex_group:   string  "'Vertex group name for modulating the wave'"
+Modifier|WaveModifier.width -> width:   float  "'NO DESCRIPTION'"
+Modifier|WaveModifier.x -> use_x:   boolean  "'X axis motion'"
+Modifier|WaveModifier.x_normal -> use_normal_x:   boolean  "'Enable displacement along the X normal'"
+Modifier|WaveModifier.y -> use_y:   boolean  "'Y axis motion'"
+Modifier|WaveModifier.y_normal -> use_normal_y:   boolean  "'Enable displacement along the Y normal'"
+Modifier|WaveModifier.z_normal -> use_normal_z:   boolean  "'Enable displacement along the Z normal'"
 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'"
@@ -2041,95 +2457,6 @@ MotionPath.points -> points:   collection,  "'(read-only)    Cached positions pe
 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'"
@@ -2167,139 +2494,205 @@ 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'"
++ * Node|CompositorNode.type -> type:   enum,  "'(read-only)'"
++ * Node|CompositorNode|CompositorNodeAlphaOver.convert_premul -> use_premultiply:   boolean  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeAlphaOver.premul -> premul:   float  "'Mix Factor'"
++ * Node|CompositorNode|CompositorNodeBilateralblur.iterations -> iterations:   int  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeBilateralblur.sigma_color -> sigma_color:   float  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeBilateralblur.sigma_space -> sigma_space:   float  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeBlur.bokeh -> use_bokeh:   boolean  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeBlur.factor -> factor:   float  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeBlur.factor_x -> factor_x:   float  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeBlur.factor_y -> factor_y:   float  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeBlur.filter_type -> filter_type:   enum  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeBlur.gamma -> use_gamma_correction:   boolean  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeBlur.relative -> use_relative:   boolean  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeBlur.sizex -> size_x:   int  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeBlur.sizey -> size_y:   int  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeChannelMatte.algorithm -> limit_method:   enum  "'Algorithm to use to limit channel'"
++ * Node|CompositorNode|CompositorNodeChannelMatte.channel -> matte_channel:   enum  "'Channel used to determine matte'"
++ * Node|CompositorNode|CompositorNodeChannelMatte.color_space -> color_space:   enum  "'NO DESCRIPTION'"
++ * Node|CompositorNode|CompositorNodeChannelMatte.high -> limit_max:   float  "'Values higher than this setting are 100% opaque'"
++ * Node|CompositorNode|CompositorNodeChannelMatte.limit_channel -> limit_channel:   enum  "'Limit by this channels value'"
++ * Node|CompositorNode|CompositorNodeChannelMatte.low -> limit_min:   float  "'Values lower than this setting are 100% keyed'"
+TODO * Node|CompositorNode|CompositorNodeChromaMatte.acceptance -> acceptance:   float  'Tolerance for a color to be considered a keying color'
+TODO * Node|CompositorNode|CompositorNodeChromaMatte.cutoff -> cutoff:   float  'Tolerance below which colors will be considered as exact matches'
+Node|CompositorNode|CompositorNodeChromaMatte.gain -> gain:   float  "'Alpha gain'"
+Node|CompositorNode|CompositorNodeChromaMatte.lift -> lift:   float  "'Alpha lift'"
+Node|CompositorNode|CompositorNodeChromaMatte.shadow_adjust -> shadow_adjust:   float  "'Adjusts the brightness of any shadows captured'"
+Node|CompositorNode|CompositorNodeColorBalance.correction_formula -> correction_formula:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeColorBalance.gain -> gain:   float  "'Correction for Highlights'"
+Node|CompositorNode|CompositorNodeColorBalance.gamma -> gamma:   float  "'Correction for Midtones'"
+Node|CompositorNode|CompositorNodeColorBalance.lift -> lift:   float  "'Correction for Shadows'"
+Node|CompositorNode|CompositorNodeColorBalance.offset -> offset:   float  "'Correction for Shadows'"
+Node|CompositorNode|CompositorNodeColorBalance.power -> power:   float  "'Correction for Midtones'"
+Node|CompositorNode|CompositorNodeColorBalance.slope -> slope:   float  "'Correction for Highlights'"
+Node|CompositorNode|CompositorNodeColorMatte.h -> h:   float  "'Hue tolerance for colors to be considered a keying color'"
+Node|CompositorNode|CompositorNodeColorMatte.s -> s:   float  "'Saturation Tolerance for the color'"
+Node|CompositorNode|CompositorNodeColorMatte.v -> v:   float  "'Value Tolerance for the color'"
+Node|CompositorNode|CompositorNodeColorSpill.algorithm -> algorithm:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeColorSpill.channel -> channel:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeColorSpill.limit_channel -> limit_channel:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeColorSpill.ratio -> ratio:   float  "'Scale limit by value'"
+Node|CompositorNode|CompositorNodeColorSpill.unspill -> use_unspill:   boolean  "'Compensate all channels (diffenrently) by hand'"
+Node|CompositorNode|CompositorNodeColorSpill.unspill_blue -> unspill_blue:   float  "'Blue spillmap scale'"
+Node|CompositorNode|CompositorNodeColorSpill.unspill_green -> unspill_green:   float  "'Green spillmap scale'"
+Node|CompositorNode|CompositorNodeColorSpill.unspill_red -> unspill_red:   float  "'Red spillmap scale'"
+Node|CompositorNode|CompositorNodeCrop.crop_size -> use_crop_size:   boolean  "'Whether to crop the size of the input image'"
+Node|CompositorNode|CompositorNodeCrop.x1 -> x1:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeCrop.x2 -> x2:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeCrop.y1 -> y1:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeCrop.y2 -> y2:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeCurveRGB.mapping -> mapping:   pointer,  "'(read-only)'"
+Node|CompositorNode|CompositorNodeCurveVec.mapping -> mapping:   pointer,  "'(read-only)'"
+Node|CompositorNode|CompositorNodeDBlur.angle -> angle:   float  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeDBlur.center_x -> center_x:   float  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeDBlur.center_y -> center_y:   float  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeDBlur.distance -> distance:   float  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeDBlur.iterations -> iterations:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeDBlur.spin -> spin:   float  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeDBlur.wrap -> use_wrap:   boolean  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeDBlur.zoom -> zoom:   float  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeDefocus.angle -> angle:   int  "'Bokeh shape rotation offset in degrees'"
+Node|CompositorNode|CompositorNodeDefocus.bokeh -> bokeh:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeDefocus.f_stop -> f_stop:   float  "'Amount of focal blur, 128=infinity=perfect focus, half the value doubles the blur radius'"
+Node|CompositorNode|CompositorNodeDefocus.gamma_correction -> use_gamma_correction:   boolean  "'Enable gamma correction before and after main process'"
+Node|CompositorNode|CompositorNodeDefocus.max_blur -> blur_max:   float  "'blur limit, maximum CoC radius, 0=no limit'"
+Node|CompositorNode|CompositorNodeDefocus.preview -> use_preview:   boolean  "'Enable sampling mode, useful for preview when using low samplecounts'"
+Node|CompositorNode|CompositorNodeDefocus.samples -> samples:   int  "'Number of samples (16=grainy, higher=less noise)'"
+Node|CompositorNode|CompositorNodeDefocus.threshold -> threshold:   float  "'CoC radius threshold, prevents background bleed on in-focus midground, 0=off'"
+Node|CompositorNode|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)'"
+Node|CompositorNode|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'"
+Node|CompositorNode|CompositorNodeDiffMatte.falloff -> falloff:   float  "'Color distances below this additional threshold are partially keyed'"
+Node|CompositorNode|CompositorNodeDiffMatte.tolerance -> tolerance:   float  "'Color distances below this threshold are keyed'"
+Node|CompositorNode|CompositorNodeDilateErode.distance -> distance:   int  "'Distance to grow/shrink (number of iterations)'"
+Node|CompositorNode|CompositorNodeDistanceMatte.falloff -> falloff:   float  "'Color distances below this additional threshold are partially keyed'"
+Node|CompositorNode|CompositorNodeDistanceMatte.tolerance -> tolerance:   float  "'Color distances below this threshold are keyed'"
+Node|CompositorNode|CompositorNodeFilter.filter_type -> filter_type:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeFlip.axis -> axis:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeGlare.angle_offset -> angle_offset:   float  "'Streak angle offset in degrees'"
+Node|CompositorNode|CompositorNodeGlare.color_modulation -> color_modulation:   float  "'Amount of Color Modulation, modulates colors of streaks and ghosts for a spectral dispersion effect'"
+Node|CompositorNode|CompositorNodeGlare.fade -> fade:   float  "'Streak fade-out factor'"
+Node|CompositorNode|CompositorNodeGlare.glare_type -> glare_type:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeGlare.iterations -> iterations:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeGlare.mix -> mix:   float  "'-1 is original image only, 0 is exact 50/50 mix, 1 is processed image only'"
+Node|CompositorNode|CompositorNodeGlare.quality -> quality:   enum  "'If not set to high quality, the effect will be applied to a low-res copy of the source image'"
+Node|CompositorNode|CompositorNodeGlare.rotate_45 -> use_rotate_45:   boolean  "'Simple star filter: add 45 degree rotation offset'"
+Node|CompositorNode|CompositorNodeGlare.size -> size:   int  "'Glow/glare size (not actual size; relative to initial size of bright area of pixels)'"
+Node|CompositorNode|CompositorNodeGlare.streaks -> streaks:   int  "'Total number of streaks'"
+Node|CompositorNode|CompositorNodeGlare.threshold -> threshold:   float  "'The glare filter will only be applied to pixels brighter than this value'"
+Node|CompositorNode|CompositorNodeHueCorrect.mapping -> mapping:   pointer,  "'(read-only)'"
+Node|CompositorNode|CompositorNodeHueSat.hue -> hue:   float  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeHueSat.sat -> sat:   float  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeHueSat.val -> val:   float  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeIDMask.index -> index:   int  "'Pass index number to convert to alpha'"
+Node|CompositorNode|CompositorNodeImage.auto_refresh -> use_auto_refresh:   boolean  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeImage.cyclic -> use_cyclic:   boolean  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeImage.frames -> frames:   int  "'Number of images used in animation'"
+Node|CompositorNode|CompositorNodeImage.image -> image:   pointer  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeImage.layer -> layer:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeImage.offset -> offset:   int  "'Offsets the number of the frame to use in the animation'"
+Node|CompositorNode|CompositorNodeImage.start -> start:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeInvert.alpha -> invert_alpha:   boolean  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeInvert.rgb -> invert_rgb:   boolean  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeLensdist.fit -> use_fit:   boolean  "'For positive distortion factor only: scale image such that black areas are not visible'"
+Node|CompositorNode|CompositorNodeLensdist.jitter -> use_jitter:   boolean  "'Enable/disable jittering; faster, but also noisier'"
+Node|CompositorNode|CompositorNodeLensdist.projector -> use_projector:   boolean  "'Enable/disable projector mode. Effect is applied in horizontal direction only'"
+Node|CompositorNode|CompositorNodeLevels.channel -> channel:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeLumaMatte.high -> high:   float  "'Values higher than this setting are 100% opaque'"
+Node|CompositorNode|CompositorNodeLumaMatte.low -> low:   float  "'Values lower than this setting are 100% keyed'"
+Node|CompositorNode|CompositorNodeMapUV.alpha -> alpha:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeMapValue.max -> max:   float  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeMapValue.min -> min:   float  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeMapValue.offset -> offset:   float  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeMapValue.size -> size:   float  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeMapValue.use_max -> use_max:   boolean  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeMapValue.use_min -> use_min:   boolean  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeMath.operation -> operation:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeMixRGB.alpha -> use_alpha:   boolean  "'Include alpha of second input in this operation'"
+Node|CompositorNode|CompositorNodeMixRGB.blend_type -> blend_type:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeOutputFile.exr_codec -> exr_codec:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeOutputFile.exr_half -> use_exr_half:   boolean  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeOutputFile.filepath -> filepath:   string  "'Output path for the image, same functionality as render output.'"
+Node|CompositorNode|CompositorNodeOutputFile.frame_end -> frame_end:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeOutputFile.frame_start -> frame_start:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeOutputFile.image_type -> image_type:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeOutputFile.quality -> quality:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodePremulKey.mapping -> mapping:   enum  "'Conversion between premultiplied alpha and key alpha'"
+Node|CompositorNode|CompositorNodeRLayers.layer -> layer:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeRLayers.scene -> scene:   pointer  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeRotate.filter -> filter:   enum  "'Method to use to filter rotation'"
+Node|CompositorNode|CompositorNodeScale.space -> space:   enum  "'Coordinate space to scale relative to'"
+Node|CompositorNode|CompositorNodeSplitViewer.axis -> axis:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeSplitViewer.factor -> factor:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeTexture.node_output -> node_output:   int  "'For node-based textures, which output node to use'"
+Node|CompositorNode|CompositorNodeTexture.texture -> texture:   pointer  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeTime.curve -> curve:   pointer,  "'(read-only)'"
+Node|CompositorNode|CompositorNodeTime.end -> end:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeTime.start -> start:   int  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeTonemap.adaptation -> adaptation:   float  "'If 0, global; if 1, based on pixel intensity'"
+Node|CompositorNode|CompositorNodeTonemap.contrast -> contrast:   float  "'Set to 0 to use estimate from input image'"
+Node|CompositorNode|CompositorNodeTonemap.correction -> correction:   float  "'If 0, same for all channels; if 1, each independent'"
+Node|CompositorNode|CompositorNodeTonemap.gamma -> gamma:   float  "'If not used, set to 1'"
+Node|CompositorNode|CompositorNodeTonemap.intensity -> intensity:   float  "'If less than zero, darkens image; otherwise, makes it brighter'"
+Node|CompositorNode|CompositorNodeTonemap.key -> key:   float  "'The value the average luminance is mapped to'"
+Node|CompositorNode|CompositorNodeTonemap.offset -> offset:   float  "'Normally always 1, but can be used as an extra control to alter the brightness curve'"
+Node|CompositorNode|CompositorNodeTonemap.tonemap_type -> tonemap_type:   enum  "'NO DESCRIPTION'"
+Node|CompositorNode|CompositorNodeValToRGB.color_ramp -> color_ramp:   pointer,  "'(read-only)'"
+Node|CompositorNode|CompositorNodeVecBlur.curved -> use_curved:   boolean  "'Interpolate between frames in a bezier curve, rather than linearly'"
+Node|CompositorNode|CompositorNodeVecBlur.factor -> factor:   float  '"Scaling factor for motion vectors; actually \'shutter speed\' in frames"'
+Node|CompositorNode|CompositorNodeVecBlur.max_speed -> speed_max:   int  "'Maximum speed, or zero for none'"
+Node|CompositorNode|CompositorNodeVecBlur.min_speed -> speed_min:   int  "'Minimum speed for a pixel to be blurred; used to separate background from foreground'"
+Node|CompositorNode|CompositorNodeVecBlur.samples -> samples:   int  "'NO DESCRIPTION'"
+Node|NodeGroup.nodetree -> nodetree:   pointer  "'NO DESCRIPTION'"
+Node|ShaderNode.type -> type:   enum,  "'(read-only)'"
+Node|ShaderNode|ShaderNodeExtendedMaterial.diffuse -> use_diffuse:   boolean  "'Material Node outputs Diffuse'"
+Node|ShaderNode|ShaderNodeExtendedMaterial.invert_normal -> invert_normal:   boolean  "'Material Node uses inverted normal'"
+Node|ShaderNode|ShaderNodeExtendedMaterial.material -> material:   pointer  "'NO DESCRIPTION'"
+Node|ShaderNode|ShaderNodeExtendedMaterial.specular -> use_specular:   boolean  "'Material Node outputs Specular'"
+Node|ShaderNode|ShaderNodeGeometry.color_layer -> color_layer:   string  "'NO DESCRIPTION'"
+Node|ShaderNode|ShaderNodeGeometry.uv_layer -> uv_layer:   string  "'NO DESCRIPTION'"
+Node|ShaderNode|ShaderNodeMapping.clamp_maximum -> use_max:   boolean  "'Clamp the output coordinate to a maximum value'"
+Node|ShaderNode|ShaderNodeMapping.clamp_minimum -> use_min:   boolean  "'Clamp the output coordinate to a minimum value'"
+Node|ShaderNode|ShaderNodeMapping.location -> location:   float  "'Location offset for the input coordinate'"
+Node|ShaderNode|ShaderNodeMapping.maximum -> max:   float  "'Maximum value to clamp coordinate to'"
+Node|ShaderNode|ShaderNodeMapping.minimum -> min:   float  "'Minimum value to clamp coordinate to'"
+Node|ShaderNode|ShaderNodeMapping.rotation -> rotation:   float  "'Rotation offset for the input coordinate'"
+Node|ShaderNode|ShaderNodeMapping.scale -> scale:   float  "'Scale adjustment for the input coordinate'"
+Node|ShaderNode|ShaderNodeMaterial.diffuse -> use_diffuse:   boolean  "'Material Node outputs Diffuse'"
+Node|ShaderNode|ShaderNodeMaterial.invert_normal -> invert_normal:   boolean  "'Material Node uses inverted normal'"
+Node|ShaderNode|ShaderNodeMaterial.material -> material:   pointer  "'NO DESCRIPTION'"
+Node|ShaderNode|ShaderNodeMaterial.specular -> use_specular:   boolean  "'Material Node outputs Specular'"
+Node|ShaderNode|ShaderNodeMath.operation -> operation:   enum  "'NO DESCRIPTION'"
+Node|ShaderNode|ShaderNodeMixRGB.alpha -> use_alpha:   boolean  "'Include alpha of second input in this operation'"
+Node|ShaderNode|ShaderNodeMixRGB.blend_type -> blend_type:   enum  "'NO DESCRIPTION'"
+Node|ShaderNode|ShaderNodeRGBCurve.mapping -> mapping:   pointer,  "'(read-only)'"
+Node|ShaderNode|ShaderNodeTexture.node_output -> node_output:   int  "'For node-based textures, which output node to use'"
+Node|ShaderNode|ShaderNodeTexture.texture -> texture:   pointer  "'NO DESCRIPTION'"
+Node|ShaderNode|ShaderNodeValToRGB.color_ramp -> color_ramp:   pointer,  "'(read-only)'"
+Node|ShaderNode|ShaderNodeVectorCurve.mapping -> mapping:   pointer,  "'(read-only)'"
+Node|ShaderNode|ShaderNodeVectorMath.operation -> operation:   enum  "'NO DESCRIPTION'"
+Node|TextureNode.type -> type:   enum,  "'(read-only)'"
+Node|TextureNode|TextureNodeBricks.offset -> offset:   float  "'NO DESCRIPTION'"
+Node|TextureNode|TextureNodeBricks.offset_frequency -> offset_frequency:   int  "'Offset every N rows'"
+Node|TextureNode|TextureNodeBricks.squash -> squash:   float  "'NO DESCRIPTION'"
+Node|TextureNode|TextureNodeBricks.squash_frequency -> squash_frequency:   int  "'Squash every N rows'"
+Node|TextureNode|TextureNodeCurveRGB.mapping -> mapping:   pointer,  "'(read-only)'"
+Node|TextureNode|TextureNodeCurveTime.curve -> curve:   pointer,  "'(read-only)'"
+Node|TextureNode|TextureNodeCurveTime.end -> end:   int  "'NO DESCRIPTION'"
+Node|TextureNode|TextureNodeCurveTime.start -> start:   int  "'NO DESCRIPTION'"
+Node|TextureNode|TextureNodeImage.image -> image:   pointer  "'NO DESCRIPTION'"
+Node|TextureNode|TextureNodeMath.operation -> operation:   enum  "'NO DESCRIPTION'"
+Node|TextureNode|TextureNodeMixRGB.alpha -> use_alpha:   boolean  "'Include alpha of second input in this operation'"
+Node|TextureNode|TextureNodeMixRGB.blend_type -> blend_type:   enum  "'NO DESCRIPTION'"
+Node|TextureNode|TextureNodeOutput.output_name -> output_name:   string  "'NO DESCRIPTION'"
+Node|TextureNode|TextureNodeTexture.node_output -> node_output:   int  "'For node-based textures, which output node to use'"
+Node|TextureNode|TextureNodeTexture.texture -> texture:   pointer  "'NO DESCRIPTION'"
+Node|TextureNode|TextureNodeValToRGB.color_ramp -> color_ramp:   pointer,  "'(read-only)'"
 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'"
@@ -2308,23 +2701,36 @@ Operator.has_reports -> has_reports:   boolean,  "'(read-only)    Operator has a
 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'"
+Paint|ImagePaint.invert_stencil -> invert_stencil:   boolean  "'Invert the stencil layer'"
+Paint|ImagePaint.normal_angle -> normal_angle:   int  "'Paint most on faces pointing towards the view according to this angle'"
+Paint|ImagePaint.screen_grab_size -> screen_grab_size:   int  "'Size to capture the image for re-projecting'"
+Paint|ImagePaint.seam_bleed -> seam_bleed:   int  "'Extend paint beyond the faces UVs to reduce seams (in pixels, slower)'"
+Paint|ImagePaint.show_brush -> show_brush:   boolean  "'Enables brush shape while not drawing'"
+Paint|ImagePaint.show_brush_draw -> show_brush_draw:   boolean  "'Enables brush shape while drawing'"
+Paint|ImagePaint.use_backface_cull -> use_backface_culling:   boolean  "'Ignore faces pointing away from the view (faster)'"
+Paint|ImagePaint.use_clone_layer -> use_clone_layer:   boolean  "'Use another UV layer as clone source, otherwise use 3D the cursor as the source'"
+Paint|ImagePaint.use_normal_falloff -> use_normal_falloff:   boolean  "'Paint most on faces pointing towards the view'"
+Paint|ImagePaint.use_occlude -> use_occlude:   boolean  "'Only paint onto the faces directly under the brush (slower)'"
+Paint|ImagePaint.use_projection -> use_projection:   boolean  "'Use projection painting for improved consistency in the brush strokes'"
+Paint|ImagePaint.use_stencil_layer -> use_stencil_layer:   boolean  "'Set the mask layer from the UV layer buttons'"
+Paint|Sculpt.lock_x -> lock_x:   boolean  "'Disallow changes to the X axis of vertices'"
+Paint|Sculpt.lock_y -> lock_y:   boolean  "'Disallow changes to the Y axis of vertices'"
+Paint|Sculpt.lock_z -> lock_z:   boolean  "'Disallow changes to the Z axis of vertices'"
+Paint|Sculpt.radial_symm -> radial_symm:   int  "'Number of times to copy strokes across the surface'"
+Paint|Sculpt.symmetry_x -> use_symmetry_x:   boolean  "'Mirror brush across the X axis'"
+Paint|Sculpt.symmetry_y -> use_symmetry_y:   boolean  "'Mirror brush across the Y axis'"
+Paint|Sculpt.symmetry_z -> use_symmetry_z:   boolean  "'Mirror brush across the Z axis'"
+Paint|Sculpt.use_openmp -> use_openmp:   boolean  "'Take advantage of multiple CPU cores to improve sculpting performance'"
+Paint|Sculpt.use_symmetry_feather -> use_symmetry_feather:   boolean  "'Reduce the strength of the brush where it overlaps symmetrical daubs'"
+Paint|VertexPaint.all_faces -> use_all_faces:   boolean  "'Paint on all faces inside brush'"
+Paint|VertexPaint.normals -> use_normal:   boolean  "'Applies the vertex normal before painting'"
+Paint|VertexPaint.spray -> use_spray:   boolean  "'Keep applying paint effect while holding mouse'"
 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'"
@@ -2334,10 +2740,6 @@ 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'"
@@ -2383,176 +2785,15 @@ 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'"
@@ -2599,7 +2840,6 @@ ParticleSystem.vertex_group_tangent -> vertex_group_tangent:   string  "'Vertex
 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'"
@@ -2607,13 +2847,6 @@ ParticleTarget.object -> object:   pointer  "'The object that has the target par
 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)'"
@@ -2648,21 +2881,6 @@ PointDensity.turbulence_influence -> turbulence_influence:   enum  "'Method for
 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'"
@@ -2719,10 +2937,6 @@ 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"'
@@ -2736,53 +2950,34 @@ Property.subtype -> subtype:   enum,  "'(read-only)    Semantic interpretation o
 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'"
++ * Property|BooleanProperty.array_length -> array_length:   int,  "'(read-only)    Maximum length of the array, 0 means unlimited'"
++ * Property|BooleanProperty.default -> default:   boolean,  "'(read-only)    Default value for this number'"
++ * Property|BooleanProperty.default_array -> default_array:   boolean,  "'(read-only)    Default value for this array'"
++ * Property|CollectionProperty.fixed_type -> fixed_type:   pointer,  "'(read-only)    Fixed pointer type, empty if variable type'"
+Property|EnumProperty.default -> default:   enum,  "'(read-only)    Default value for this enum'"
+Property|EnumProperty.items -> items:   collection,  "'(read-only)    Possible values for the property'"
+Property|FloatProperty.array_length -> array_length:   int,  "'(read-only)    Maximum length of the array, 0 means unlimited'"
+Property|FloatProperty.default -> default:   float,  "'(read-only)    Default value for this number'"
+Property|FloatProperty.default_array -> default_array:   float,  "'(read-only)    Default value for this array'"
+Property|FloatProperty.hard_max -> hard_max:   float,  "'(read-only)    Maximum value used by buttons'"
+Property|FloatProperty.hard_min -> hard_min:   float,  "'(read-only)    Minimum value used by buttons'"
+Property|FloatProperty.precision -> precision:   int,  "'(read-only)    Number of digits after the dot used by buttons'"
+Property|FloatProperty.soft_max -> soft_max:   float,  "'(read-only)    Maximum value used by buttons'"
+Property|FloatProperty.soft_min -> soft_min:   float,  "'(read-only)    Minimum value used by buttons'"
+Property|FloatProperty.step -> step:   float,  "'(read-only)    Step size used by number buttons, for floats 1/100th of the step size'"
+Property|IntProperty.array_length -> array_length:   int,  "'(read-only)    Maximum length of the array, 0 means unlimited'"
+Property|IntProperty.default -> default:   int,  "'(read-only)    Default value for this number'"
+Property|IntProperty.default_array -> default_array:   int,  "'(read-only)    Default value for this array'"
+Property|IntProperty.hard_max -> hard_max:   int,  "'(read-only)    Maximum value used by buttons'"
+Property|IntProperty.hard_min -> hard_min:   int,  "'(read-only)    Minimum value used by buttons'"
+Property|IntProperty.soft_max -> soft_max:   int,  "'(read-only)    Maximum value used by buttons'"
+Property|IntProperty.soft_min -> soft_min:   int,  "'(read-only)    Minimum value used by buttons'"
+Property|IntProperty.step -> step:   int,  "'(read-only)    Step size used by number buttons, for floats 1/100th of the step size'"
+Property|PointerProperty.fixed_type -> fixed_type:   pointer,  "'(read-only)    Fixed pointer type, empty if variable type'"
+Property|StringProperty.default -> default:   string,  "'(read-only)    string default value'"
+Property|StringProperty.max_length -> length_max:   int,  "'(read-only)    Maximum length of the string, 0 means unlimited'"
 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'"
@@ -2957,17 +3152,6 @@ RenderSettings.use_shadows -> use_shadows:   boolean  "'Calculate shadows while
 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'"
@@ -2977,52 +3161,6 @@ 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'"
@@ -3106,58 +3244,12 @@ SceneRenderLayer.zmask -> use_zmask:   boolean  '"Only render what\'s in front o
 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'"
@@ -3168,6 +3260,56 @@ Sensor.pulse_false_level -> use_pulse_false_level:   boolean  "'Activate FALSE l
 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'"
++ * Sensor|ActuatorSensor.actuator -> actuator:   string  "'Actuator name, actuator active state modifications will be detected'"
++ * Sensor|ArmatureSensor.bone -> bone:   string  "'Identify the bone to check value from'"
++ * Sensor|ArmatureSensor.constraint -> constraint:   string  "'Identify the bone constraint to check value from'"
++ * Sensor|ArmatureSensor.test_type -> test_type:   enum  "'Type of value and test'"
++ * Sensor|ArmatureSensor.value -> value:   float  "'Specify value to be used in comparison'"
++ * Sensor|CollisionSensor.collision_type -> use_material:   boolean  "'Use material instead of property'"
++ * Sensor|CollisionSensor.material -> material:   string  "'Only look for Objects with this material'"
++ * Sensor|CollisionSensor.property -> property:   string  "'Only look for Objects with this property'"
++ * Sensor|CollisionSensor.pulse -> use_pulse:   boolean  "'Changes to the set of colliding objects generates pulse'"
+Sensor|DelaySensor.delay -> delay:   int  "'Delay in number of logic tics before the positive trigger (default 60 per second)'"
+Sensor|DelaySensor.duration -> duration:   int  "'If >0, delay in number of logic tics before the negative trigger following the positive trigger'"
+Sensor|DelaySensor.repeat -> use_repeat:   boolean  "'Toggle repeat option. If selected, the sensor restarts after Delay+Dur logic tics'"
+Sensor|JoystickSensor.all_events -> use_all_events:   boolean  "'Triggered by all events on this joysticks current type (axis/button/hat)'"
+Sensor|JoystickSensor.axis_direction -> axis_direction:   enum  "'The direction of the axis'"
+Sensor|JoystickSensor.axis_number -> axis_number:   int  "'Specify which axis pair to use, 1 is usually the main direction input'"
+Sensor|JoystickSensor.axis_threshold -> axis_threshold:   int  "'Specify the precision of the axis'"
+Sensor|JoystickSensor.button_number -> button_number:   int  "'Specify which button to use'"
+Sensor|JoystickSensor.event_type -> event_type:   enum  "'The type of event this joystick sensor is triggered on'"
+Sensor|JoystickSensor.hat_direction -> hat_direction:   enum  "'Specify hat direction'"
+Sensor|JoystickSensor.hat_number -> hat_number:   int  "'Specify which hat to use'"
+Sensor|JoystickSensor.joystick_index -> joystick_index:   int  "'Specify which joystick to use'"
+Sensor|JoystickSensor.single_axis_number -> single_axis_number:   int  "'Specify a single axis (verticle/horizontal/other) to detect'"
+Sensor|KeyboardSensor.all_keys -> use_all_keys:   boolean  "'Trigger this sensor on any keystroke'"
+Sensor|KeyboardSensor.key -> key:   enum  "'NO DESCRIPTION'"
+Sensor|KeyboardSensor.log -> log:   string  "'Property that receive the keystrokes in case a string is logged'"
+Sensor|KeyboardSensor.modifier_key -> modifier_key:   enum  "'Modifier key code'"
+Sensor|KeyboardSensor.second_modifier_key -> second_modifier_key:   enum  "'Modifier key code'"
+Sensor|KeyboardSensor.target -> target:   string  "'Property that indicates whether to log keystrokes as a string'"
+Sensor|MessageSensor.subject -> subject:   string  "'Optional subject filter: only accept messages with this subject, or empty for all'"
+Sensor|MouseSensor.mouse_event -> mouse_event:   enum  "'Specify the type of event this mouse sensor should trigger on'"
+Sensor|NearSensor.distance -> distance:   float  "'Trigger distance'"
+Sensor|NearSensor.property -> property:   string  "'Only look for objects with this property'"
+Sensor|NearSensor.reset_distance -> reset_distance:   float  "'NO DESCRIPTION'"
+Sensor|PropertySensor.evaluation_type -> evaluation_type:   enum  "'Type of property evaluation'"
+Sensor|PropertySensor.max_value -> value_max:   string  "'Specify maximum value in Interval type'"
+Sensor|PropertySensor.min_value -> value_min:   string  "'Specify minimum value in Interval type'"
+Sensor|PropertySensor.property -> property:   string  "'NO DESCRIPTION'"
+Sensor|PropertySensor.value -> value:   string  "'Check for this value in types in Equal or Not Equal types'"
+Sensor|RadarSensor.angle -> angle:   float  "'Opening angle of the radar cone'"
+Sensor|RadarSensor.axis -> axis:   enum  "'Specify along which axis the radar cone is cast'"
+Sensor|RadarSensor.distance -> distance:   float  "'Depth of the radar cone'"
+Sensor|RadarSensor.property -> property:   string  "'Only look for Objects with this property'"
+Sensor|RandomSensor.seed -> seed:   int  "'Initial seed of the generator. (Choose 0 for not random)'"
+Sensor|RaySensor.axis -> axis:   enum  "'Specify along which axis the ray is cast'"
+Sensor|RaySensor.material -> material:   string  "'Only look for Objects with this material'"
+Sensor|RaySensor.property -> property:   string  "'Only look for Objects with this property'"
+Sensor|RaySensor.range -> range:   float  "'Sense objects no farther than this distance'"
+Sensor|RaySensor.ray_type -> ray_type:   enum  "'Toggle collision on material or property'"
+Sensor|RaySensor.x_ray_mode -> use_x_ray:   boolean  '"See through objects that don\'t have the property"'
+Sensor|TouchSensor.material -> material:   pointer  "'Only look for objects with this material'"
 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'"
@@ -3212,42 +3354,168 @@ SequenceProxy.directory -> directory:   string  "'Location to store the proxy fi
 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'"
+Sequence|EffectSequence.color_balance -> color_balance:   pointer,  "'(read-only)'"
+Sequence|EffectSequence.color_saturation -> color_saturation:   float  "'NO DESCRIPTION'"
+Sequence|EffectSequence.convert_float -> use_float:   boolean  "'Convert input to float data'"
+Sequence|EffectSequence.crop -> crop:   pointer,  "'(read-only)'"
+Sequence|EffectSequence.de_interlace -> use_deinterlace:   boolean  "'For video movies to remove fields'"
+Sequence|EffectSequence.flip_x -> use_flip_x:   boolean  "'Flip on the X axis'"
+Sequence|EffectSequence.flip_y -> use_flip_y:   boolean  "'Flip on the Y axis'"
+Sequence|EffectSequence.multiply_colors -> color_multiply:   float  "'NO DESCRIPTION'"
+Sequence|EffectSequence.premultiply -> use_premultiply:   boolean  "'Convert RGB from key alpha to premultiplied alpha'"
+Sequence|EffectSequence.proxy -> proxy:   pointer,  "'(read-only)'"
+Sequence|EffectSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  "'Use a custom directory to store data'"
+Sequence|EffectSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  "'Use a custom file to read proxy data from'"
+Sequence|EffectSequence.reverse_frames -> use_reverse_frames:   boolean  "'Reverse frame order'"
+Sequence|EffectSequence.strobe -> strobe:   float  "'Only display every nth frame'"
+Sequence|EffectSequence.transform -> transform:   pointer,  "'(read-only)'"
+Sequence|EffectSequence.use_color_balance -> use_color_balance:   boolean  "'(3-Way color correction) on input'"
+Sequence|EffectSequence.use_crop -> use_crop:   boolean  "'Crop image before processing'"
+Sequence|EffectSequence.use_proxy -> use_proxy:   boolean  "'Use a preview proxy for this strip'"
+Sequence|EffectSequence.use_translation -> use_translation:   boolean  "'Translate image before processing'"
++ * Sequence|EffectSequence|ColorSequence.color -> color:   float  "'NO DESCRIPTION'"
+Sequence|EffectSequence|GlowSequence.blur_distance -> blur_distance:   float  "'Radius of glow effect'"
+Sequence|EffectSequence|GlowSequence.boost_factor -> boost_factor:   float  "'Brightness multiplier'"
+Sequence|EffectSequence|GlowSequence.clamp -> clamp:   float  "'rightness limit of intensity'"
+Sequence|EffectSequence|GlowSequence.only_boost -> use_only_boost:   boolean  "'Show the glow buffer only'"
+Sequence|EffectSequence|GlowSequence.quality -> quality:   int  "'Accuracy of the blur effect'"
+Sequence|EffectSequence|GlowSequence.threshold -> threshold:   float  "'Minimum intensity to trigger a glow'"
+Sequence|EffectSequence|PluginSequence.filename -> filename:   string,  "'(read-only)'"
+Sequence|EffectSequence|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'"
+Sequence|EffectSequence|SpeedControlSequence.curve_velocity -> use_curve_velocity:   boolean  "'Interpret the F-Curve value as a velocity instead of a frame number'"
+Sequence|EffectSequence|SpeedControlSequence.frame_blending -> use_frame_blend:   boolean  "'Blend two frames into the target for a smoother result'"
+Sequence|EffectSequence|SpeedControlSequence.global_speed -> global_speed:   float  "'NO DESCRIPTION'"
+Sequence|EffectSequence|TransformSequence.interpolation -> interpolation:   enum  "'NO DESCRIPTION'"
+Sequence|EffectSequence|TransformSequence.rotation_start -> rotation_start:   float  "'NO DESCRIPTION'"
+Sequence|EffectSequence|TransformSequence.scale_start_x -> scale_start_x:   float  "'NO DESCRIPTION'"
+Sequence|EffectSequence|TransformSequence.scale_start_y -> scale_start_y:   float  "'NO DESCRIPTION'"
+Sequence|EffectSequence|TransformSequence.translate_start_x -> translate_start_x:   float  "'NO DESCRIPTION'"
+Sequence|EffectSequence|TransformSequence.translate_start_y -> translate_start_y:   float  "'NO DESCRIPTION'"
+Sequence|EffectSequence|TransformSequence.translation_unit -> translation_unit:   enum  "'NO DESCRIPTION'"
+Sequence|EffectSequence|TransformSequence.uniform_scale -> use_uniform_scale:   boolean  "'Scale uniformly, preserving aspect ratio'"
+Sequence|EffectSequence|WipeSequence.angle -> angle:   float  "'Edge angle'"
+Sequence|EffectSequence|WipeSequence.blur_width -> blur_width:   float  "'Width of the blur edge, in percentage relative to the image size'"
+Sequence|EffectSequence|WipeSequence.direction -> direction:   enum  "'Wipe direction'"
+Sequence|EffectSequence|WipeSequence.transition_type -> transition_type:   enum  "'NO DESCRIPTION'"
+Sequence|ImageSequence.animation_end_offset -> animation_end_offset:   int  "'Animation end offset (trim end)'"
+Sequence|ImageSequence.animation_start_offset -> animation_start_offset:   int  "'Animation start offset (trim start)'"
+Sequence|ImageSequence.color_balance -> color_balance:   pointer,  "'(read-only)'"
+Sequence|ImageSequence.color_saturation -> color_saturation:   float  "'NO DESCRIPTION'"
+Sequence|ImageSequence.convert_float -> use_float:   boolean  "'Convert input to float data'"
+Sequence|ImageSequence.crop -> crop:   pointer,  "'(read-only)'"
+Sequence|ImageSequence.de_interlace -> use_deinterlace:   boolean  "'For video movies to remove fields'"
+Sequence|ImageSequence.directory -> directory:   string  "'NO DESCRIPTION'"
+Sequence|ImageSequence.elements -> elements:   collection,  "'(read-only)'"
+Sequence|ImageSequence.flip_x -> use_flip_x:   boolean  "'Flip on the X axis'"
+Sequence|ImageSequence.flip_y -> use_flip_y:   boolean  "'Flip on the Y axis'"
+Sequence|ImageSequence.multiply_colors -> multiply_colors:   float  "'NO DESCRIPTION'"
+Sequence|ImageSequence.premultiply -> use_premultiply:   boolean  "'Convert RGB from key alpha to premultiplied alpha'"
+Sequence|ImageSequence.proxy -> proxy:   pointer,  "'(read-only)'"
+Sequence|ImageSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  "'Use a custom directory to store data'"
+Sequence|ImageSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  "'Use a custom file to read proxy data from'"
+Sequence|ImageSequence.reverse_frames -> use_reverse_frames:   boolean  "'Reverse frame order'"
+Sequence|ImageSequence.strobe -> strobe:   float  "'Only display every nth frame'"
+Sequence|ImageSequence.transform -> transform:   pointer,  "'(read-only)'"
+Sequence|ImageSequence.use_color_balance -> use_color_balance:   boolean  "'(3-Way color correction) on input'"
+Sequence|ImageSequence.use_crop -> use_crop:   boolean  "'Crop image before processing'"
+Sequence|ImageSequence.use_proxy -> use_proxy:   boolean  "'Use a preview proxy for this strip'"
+Sequence|ImageSequence.use_translation -> use_translation:   boolean  "'Translate image before processing'"
+Sequence|MetaSequence.animation_end_offset -> animation_end_offset:   int  "'Animation end offset (trim end)'"
+Sequence|MetaSequence.animation_start_offset -> animation_start_offset:   int  "'Animation start offset (trim start)'"
+Sequence|MetaSequence.color_balance -> color_balance:   pointer,  "'(read-only)'"
+Sequence|MetaSequence.color_saturation -> color_saturation:   float  "'NO DESCRIPTION'"
+Sequence|MetaSequence.convert_float -> use_float:   boolean  "'Convert input to float data'"
+Sequence|MetaSequence.crop -> crop:   pointer,  "'(read-only)'"
+Sequence|MetaSequence.de_interlace -> use_deinterlace:   boolean  "'For video movies to remove fields'"
+Sequence|MetaSequence.flip_x -> use_flip_x:   boolean  "'Flip on the X axis'"
+Sequence|MetaSequence.flip_y -> use_flip_y:   boolean  "'Flip on the Y axis'"
+Sequence|MetaSequence.multiply_colors -> multiply_colors:   float  "'NO DESCRIPTION'"
+Sequence|MetaSequence.premultiply -> use_premultiply:   boolean  "'Convert RGB from key alpha to premultiplied alpha'"
+Sequence|MetaSequence.proxy -> proxy:   pointer,  "'(read-only)'"
+Sequence|MetaSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  "'Use a custom directory to store data'"
+Sequence|MetaSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  "'Use a custom file to read proxy data from'"
+Sequence|MetaSequence.reverse_frames -> use_reverse_frames:   boolean  "'Reverse frame order'"
+Sequence|MetaSequence.sequences -> sequences:   collection,  "'(read-only)'"
+Sequence|MetaSequence.strobe -> strobe:   float  "'Only display every nth frame'"
+Sequence|MetaSequence.transform -> transform:   pointer,  "'(read-only)'"
+Sequence|MetaSequence.use_color_balance -> use_color_balance:   boolean  "'(3-Way color correction) on input'"
+Sequence|MetaSequence.use_crop -> use_crop:   boolean  "'Crop image before processing'"
+Sequence|MetaSequence.use_proxy -> use_proxy:   boolean  "'Use a preview proxy for this strip'"
+Sequence|MetaSequence.use_translation -> use_translation:   boolean  "'Translate image before processing'"
+Sequence|MovieSequence.animation_end_offset -> animation_end_offset:   int  "'Animation end offset (trim end)'"
+Sequence|MovieSequence.animation_start_offset -> animation_start_offset:   int  "'Animation start offset (trim start)'"
+Sequence|MovieSequence.color_balance -> color_balance:   pointer,  "'(read-only)'"
+Sequence|MovieSequence.color_saturation -> color_saturation:   float  "'NO DESCRIPTION'"
+Sequence|MovieSequence.convert_float -> use_float:   boolean  "'Convert input to float data'"
+Sequence|MovieSequence.crop -> crop:   pointer,  "'(read-only)'"
+Sequence|MovieSequence.de_interlace -> use_deinterlace:   boolean  "'For video movies to remove fields'"
+Sequence|MovieSequence.filepath -> filepath:   string  "'NO DESCRIPTION'"
+Sequence|MovieSequence.flip_x -> use_flip_x:   boolean  "'Flip on the X axis'"
+Sequence|MovieSequence.flip_y -> use_flip_y:   boolean  "'Flip on the Y axis'"
+Sequence|MovieSequence.mpeg_preseek -> mpeg_preseek:   int  "'For MPEG movies, preseek this many frames'"
+Sequence|MovieSequence.multiply_colors -> multiply_colors:   float  "'NO DESCRIPTION'"
+Sequence|MovieSequence.premultiply -> use_premultiply:   boolean  "'Convert RGB from key alpha to premultiplied alpha'"
+Sequence|MovieSequence.proxy -> proxy:   pointer,  "'(read-only)'"
+Sequence|MovieSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  "'Use a custom directory to store data'"
+Sequence|MovieSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  "'Use a custom file to read proxy data from'"
+Sequence|MovieSequence.reverse_frames -> use_reverse_frames:   boolean  "'Reverse frame order'"
+Sequence|MovieSequence.strobe -> strobe:   float  "'Only display every nth frame'"
+Sequence|MovieSequence.transform -> transform:   pointer,  "'(read-only)'"
+Sequence|MovieSequence.use_color_balance -> use_color_balance:   boolean  "'(3-Way color correction) on input'"
+Sequence|MovieSequence.use_crop -> use_crop:   boolean  "'Crop image before processing'"
+Sequence|MovieSequence.use_proxy -> use_proxy:   boolean  "'Use a preview proxy for this strip'"
+Sequence|MovieSequence.use_translation -> use_translation:   boolean  "'Translate image before processing'"
+Sequence|MulticamSequence.animation_end_offset -> animation_end_offset:   int  "'Animation end offset (trim end)'"
+Sequence|MulticamSequence.animation_start_offset -> animation_start_offset:   int  "'Animation start offset (trim start)'"
+Sequence|MulticamSequence.color_balance -> color_balance:   pointer,  "'(read-only)'"
+Sequence|MulticamSequence.color_saturation -> color_saturation:   float  "'NO DESCRIPTION'"
+Sequence|MulticamSequence.convert_float -> use_float:   boolean  "'Convert input to float data'"
+Sequence|MulticamSequence.crop -> crop:   pointer,  "'(read-only)'"
+Sequence|MulticamSequence.de_interlace -> use_deinterlace:   boolean  "'For video movies to remove fields'"
+Sequence|MulticamSequence.flip_x -> use_flip_x:   boolean  "'Flip on the X axis'"
+Sequence|MulticamSequence.flip_y -> use_flip_y:   boolean  "'Flip on the Y axis'"
+Sequence|MulticamSequence.multicam_source -> multicam_source:   int  "'NO DESCRIPTION'"
+Sequence|MulticamSequence.multiply_colors -> multiply_colors:   float  "'NO DESCRIPTION'"
+Sequence|MulticamSequence.premultiply -> use_premultiply:   boolean  "'Convert RGB from key alpha to premultiplied alpha'"
+Sequence|MulticamSequence.proxy -> proxy:   pointer,  "'(read-only)'"
+Sequence|MulticamSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  "'Use a custom directory to store data'"
+Sequence|MulticamSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  "'Use a custom file to read proxy data from'"
+Sequence|MulticamSequence.reverse_frames -> use_reverse_frames:   boolean  "'Reverse frame order'"
+Sequence|MulticamSequence.strobe -> strobe:   float  "'Only display every nth frame'"
+Sequence|MulticamSequence.transform -> transform:   pointer,  "'(read-only)'"
+Sequence|MulticamSequence.use_color_balance -> use_color_balance:   boolean  "'(3-Way color correction) on input'"
+Sequence|MulticamSequence.use_crop -> use_crop:   boolean  "'Crop image before processing'"
+Sequence|MulticamSequence.use_proxy -> use_proxy:   boolean  "'Use a preview proxy for this strip'"
+Sequence|MulticamSequence.use_translation -> use_translation:   boolean  "'Translate image before processing'"
+Sequence|SceneSequence.animation_end_offset -> animation_end_offset:   int  "'Animation end offset (trim end)'"
+Sequence|SceneSequence.animation_start_offset -> animation_start_offset:   int  "'Animation start offset (trim start)'"
+Sequence|SceneSequence.color_balance -> color_balance:   pointer,  "'(read-only)'"
+Sequence|SceneSequence.color_saturation -> color_saturation:   float  "'NO DESCRIPTION'"
+Sequence|SceneSequence.convert_float -> use_float:   boolean  "'Convert input to float data'"
+Sequence|SceneSequence.crop -> crop:   pointer,  "'(read-only)'"
+Sequence|SceneSequence.de_interlace -> use_deinterlace:   boolean  "'For video movies to remove fields'"
+Sequence|SceneSequence.flip_x -> use_flip_x:   boolean  "'Flip on the X axis'"
+Sequence|SceneSequence.flip_y -> use_flip_y:   boolean  "'Flip on the Y axis'"
+Sequence|SceneSequence.multiply_colors -> multiply_colors:   float  "'NO DESCRIPTION'"
+Sequence|SceneSequence.premultiply -> use_premultiply:   boolean  "'Convert RGB from key alpha to premultiplied alpha'"
+Sequence|SceneSequence.proxy -> proxy:   pointer,  "'(read-only)'"
+Sequence|SceneSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  "'Use a custom directory to store data'"
+Sequence|SceneSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  "'Use a custom file to read proxy data from'"
+Sequence|SceneSequence.reverse_frames -> use_reverse_frames:   boolean  "'Reverse frame order'"
+Sequence|SceneSequence.scene -> scene:   pointer  "'Scene that this sequence uses'"
+Sequence|SceneSequence.scene_camera -> scene_camera:   pointer  "'Override the scenes active camera'"
+Sequence|SceneSequence.strobe -> strobe:   float  "'Only display every nth frame'"
+Sequence|SceneSequence.transform -> transform:   pointer,  "'(read-only)'"
+Sequence|SceneSequence.use_color_balance -> use_color_balance:   boolean  "'(3-Way color correction) on input'"
+Sequence|SceneSequence.use_crop -> use_crop:   boolean  "'Crop image before processing'"
+Sequence|SceneSequence.use_proxy -> use_proxy:   boolean  "'Use a preview proxy for this strip'"
+Sequence|SceneSequence.use_translation -> use_translation:   boolean  "'Translate image before processing'"
+Sequence|SoundSequence.animation_end_offset -> animation_end_offset:   int  "'Animation end offset (trim end)'"
+Sequence|SoundSequence.animation_start_offset -> animation_start_offset:   int  "'Animation start offset (trim start)'"
+Sequence|SoundSequence.attenuation -> attenuation:   float  "'Attenuation in dezibel'"
+Sequence|SoundSequence.filepath -> filepath:   string  "'NO DESCRIPTION'"
+Sequence|SoundSequence.sound -> sound:   pointer,  "'(read-only)    Sound datablock used by this sequence'"
+Sequence|SoundSequence.volume -> volume:   float  "'Playback volume of the sound'"
 ShapeKey.data -> data:   collection,  "'(read-only)'"
 ShapeKey.frame -> frame:   float,  "'(read-only)    Frame for absolute keys'"
 ShapeKey.interpolation -> interpolation:   enum  "'Interpolation type'"
@@ -3264,34 +3532,6 @@ 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'"
@@ -3322,18 +3562,6 @@ NEGATE * SmokeFlowSettings.outflow -> use_outflow:   boolean  "'Deletes smoke fr
 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'"
@@ -3377,169 +3605,7 @@ SoftBodySettings.spring_vertex_group -> spring_vertex_group:   string  "'Control
 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'"
@@ -3553,48 +3619,173 @@ SpaceUVEditor.normalized_coordinates -> show_normalized_coordinates:   boolean
 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'"
+Space|SpaceConsole.console_type -> console_type:   enum  "'Console type'"
+Space|SpaceConsole.font_size -> font_size:   int  "'Font size to use for displaying the text'"
+Space|SpaceConsole.history -> history:   collection,  "'(read-only)    Command history'"
+Space|SpaceConsole.language -> language:   string  "'Command line prompt language'"
+Space|SpaceConsole.prompt -> prompt:   string  "'Command line prompt'"
+Space|SpaceConsole.scrollback -> scrollback:   collection,  "'(read-only)    Command output'"
+Space|SpaceConsole.selection_end -> selection_end:   int  "'NO DESCRIPTION'"
+Space|SpaceConsole.selection_start -> selection_start:   int  "'NO DESCRIPTION'"
+Space|SpaceConsole.show_report_debug -> show_report_debug:   boolean  "'Display debug reporting info'"
+Space|SpaceConsole.show_report_error -> show_report_error:   boolean  "'Display error text'"
+Space|SpaceConsole.show_report_info -> show_report_info:   boolean  "'Display general information'"
+Space|SpaceConsole.show_report_operator -> show_report_operator:   boolean  "'Display the operator log'"
+Space|SpaceConsole.show_report_warn -> show_report_warning:   boolean  "'Display warnings'"
+Space|SpaceDopeSheetEditor.action -> action:   pointer  "'Action displayed and edited in this space'"
+Space|SpaceDopeSheetEditor.automerge_keyframes -> use_automerge_keyframes:   boolean  "'Automatically merge nearby keyframes'"
+Space|SpaceDopeSheetEditor.autosnap -> autosnap:   enum  "'Automatic time snapping settings for transformations'"
+Space|SpaceDopeSheetEditor.dopesheet -> dopesheet:   pointer,  "'(read-only)    Settings for filtering animation data'"
+Space|SpaceDopeSheetEditor.mode -> mode:   enum  "'Editing context being displayed'"
+Space|SpaceDopeSheetEditor.realtime_updates -> use_realtime_updates:   boolean  "'When transforming keyframes, changes to the animation data are flushed to other views'"
+Space|SpaceDopeSheetEditor.show_cframe_indicator -> show_frame_indicator:   boolean  "'Show frame number beside the current frame indicator line'"
+Space|SpaceDopeSheetEditor.show_seconds -> show_seconds:   boolean,  "'(read-only)    Show timing in seconds not frames'"
+Space|SpaceDopeSheetEditor.show_sliders -> show_sliders:   boolean  "'Show sliders beside F-Curve channels'"
+Space|SpaceDopeSheetEditor.use_marker_sync -> use_marker_sync:   boolean  "'Sync Markers with keyframe edits'"
+Space|SpaceFileBrowser.params -> params:   pointer,  "'(read-only)    Parameters and Settings for the Filebrowser'"
+Space|SpaceGraphEditor.automerge_keyframes -> use_automerge_keyframes:   boolean  "'Automatically merge nearby keyframes'"
+Space|SpaceGraphEditor.autosnap -> autosnap:   enum  "'Automatic time snapping settings for transformations'"
+Space|SpaceGraphEditor.cursor_value -> cursor_value:   float  "'Graph Editor 2D-Value cursor - Y-Value component'"
+Space|SpaceGraphEditor.dopesheet -> dopesheet:   pointer,  "'(read-only)    Settings for filtering animation data'"
+Space|SpaceGraphEditor.has_ghost_curves -> has_ghost_curves:   boolean  "'Graph Editor instance has some ghost curves stored'"
+Space|SpaceGraphEditor.mode -> mode:   enum  "'Editing context being displayed'"
+Space|SpaceGraphEditor.only_selected_curves_handles -> use_only_selected_curves_handles:   boolean  "'Only keyframes of selected F-Curves are visible and editable'"
+Space|SpaceGraphEditor.only_selected_keyframe_handles -> use_only_selected_keyframe_handles:   boolean  "'Only show and edit handles of selected keyframes'"
+Space|SpaceGraphEditor.pivot_point -> pivot_point:   enum  "'Pivot center for rotation/scaling'"
+Space|SpaceGraphEditor.realtime_updates -> use_realtime_updates:   boolean  "'When transforming keyframes, changes to the animation data are flushed to other views'"
+Space|SpaceGraphEditor.show_cframe_indicator -> show_frame_indicator:   boolean  "'Show frame number beside the current frame indicator line'"
+Space|SpaceGraphEditor.show_cursor -> show_cursor:   boolean  "'Show 2D cursor'"
+Space|SpaceGraphEditor.show_handles -> show_handles:   boolean  "'Show handles of Bezier control points'"
+Space|SpaceGraphEditor.show_seconds -> show_seconds:   boolean,  "'(read-only)    Show timing in seconds not frames'"
+Space|SpaceGraphEditor.show_sliders -> show_sliders:   boolean  "'Show sliders beside F-Curve channels'"
+Space|SpaceImageEditor.curves -> curves:   pointer,  "'(read-only)    Color curve mapping to use for displaying the image'"
+Space|SpaceImageEditor.draw_channels -> draw_channels:   enum  "'Channels of the image to draw'"
+Space|SpaceImageEditor.draw_repeated -> show_repeated:   boolean  "'Draw the image repeated outside of the main view'"
+Space|SpaceImageEditor.grease_pencil -> grease_pencil:   pointer  "'Grease pencil data for this space'"
+Space|SpaceImageEditor.image -> image:   pointer  "'Image displayed and edited in this space'"
+Space|SpaceImageEditor.image_painting -> use_image_paint:   boolean  "'Enable image painting mode'"
+Space|SpaceImageEditor.image_pin -> use_image_pin:   boolean  "'Display current image regardless of object selection'"
+Space|SpaceImageEditor.image_user -> image_user:   pointer,  "'(read-only)    Parameters defining which layer, pass and frame of the image is displayed'"
+Space|SpaceImageEditor.sample_histogram -> sample_histogram:   pointer,  "'(read-only)    Sampled colors along line'"
+Space|SpaceImageEditor.scopes -> scopes:   pointer,  "'(read-only)    Scopes to visualize image statistics.'"
+Space|SpaceImageEditor.show_paint -> show_paint:   boolean,  "'(read-only)    Show paint related properties'"
+Space|SpaceImageEditor.show_render -> show_render:   boolean,  "'(read-only)    Show render related properties'"
+Space|SpaceImageEditor.show_uvedit -> show_uvedit:   boolean,  "'(read-only)    Show UV editing related properties'"
+Space|SpaceImageEditor.update_automatically -> use_realtime_updates:   boolean  "'Update other affected window spaces automatically to reflect changes during interactive operations such as transform'"
+Space|SpaceImageEditor.use_grease_pencil -> use_grease_pencil:   boolean  "'Display and edit the grease pencil freehand annotations overlay'"
+Space|SpaceImageEditor.uv_editor -> uv_editor:   pointer,  "'(read-only)    UV editor settings'"
+Space|SpaceLogicEditor.actuators_show_active_objects -> show_actuators_active_objects:   boolean  "'Show actuators of active object'"
+Space|SpaceLogicEditor.actuators_show_active_states -> show_actuators_active_states:   boolean  "'Show only actuators connected to active states'"
+Space|SpaceLogicEditor.actuators_show_linked_controller -> show_actuators_linked_controller:   boolean  "'Show linked objects to the actuator'"
+Space|SpaceLogicEditor.actuators_show_selected_objects -> show_actuators_selected_objects:   boolean  "'Show actuators of all selected objects'"
+Space|SpaceLogicEditor.controllers_show_active_objects -> show_controllers_active_objects:   boolean  "'Show controllers of active object'"
+Space|SpaceLogicEditor.controllers_show_linked_controller -> show_controllers_linked_controller:   boolean  "'Show linked objects to sensor/actuator'"
+Space|SpaceLogicEditor.controllers_show_selected_objects -> show_controllers_selected_objects:   boolean  "'Show controllers of all selected objects'"
+Space|SpaceLogicEditor.sensors_show_active_objects -> show_sensors_active_objects:   boolean  "'Show sensors of active object'"
+Space|SpaceLogicEditor.sensors_show_active_states -> show_sensors_active_states:   boolean  "'Show only sensors connected to active states'"
+Space|SpaceLogicEditor.sensors_show_linked_controller -> show_sensors_linked_controller:   boolean  "'Show linked objects to the controller'"
+Space|SpaceLogicEditor.sensors_show_selected_objects -> show_sensors_selected_objects:   boolean  "'Show sensors of all selected objects'"
+Space|SpaceNLA.autosnap -> autosnap:   enum  "'Automatic time snapping settings for transformations'"
+Space|SpaceNLA.dopesheet -> dopesheet:   pointer,  "'(read-only)    Settings for filtering animation data'"
+Space|SpaceNLA.realtime_updates -> use_realtime_updates:   boolean  "'When transforming strips, changes to the animation data are flushed to other views'"
+Space|SpaceNLA.show_cframe_indicator -> show_frame_indicator:   boolean  "'Show frame number beside the current frame indicator line'"
+Space|SpaceNLA.show_seconds -> show_seconds:   boolean,  "'(read-only)    Show timing in seconds not frames'"
+Space|SpaceNLA.show_strip_curves -> show_strip_curves:   boolean  "'Show influence curves on strips'"
+Space|SpaceNodeEditor.backdrop -> show_backdrop:   boolean  "'Use active Viewer Node output as backdrop for compositing nodes'"
+Space|SpaceNodeEditor.id -> id:   pointer,  "'(read-only)    Datablock whose nodes are being edited'"
+Space|SpaceNodeEditor.id_from -> id_from:   pointer,  "'(read-only)    Datablock from which the edited datablock is linked'"
+Space|SpaceNodeEditor.nodetree -> nodetree:   pointer,  "'(read-only)    Node tree being displayed and edited'"
+Space|SpaceNodeEditor.texture_type -> texture_type:   enum  "'Type of data to take texture from'"
+Space|SpaceNodeEditor.tree_type -> tree_type:   enum  "'Node tree type to display and edit'"
+Space|SpaceOutliner.display_filter -> display_filter:   string  "'Live search filtering string'"
+Space|SpaceOutliner.display_mode -> display_mode:   enum  "'Type of information to display'"
+Space|SpaceOutliner.match_case_sensitive -> use_match_case_sensitive:   boolean  "'Only use case sensitive matches of search string'"
+Space|SpaceOutliner.match_complete -> use_match_complete:   boolean  "'Only use complete matches of search string'"
+Space|SpaceOutliner.show_restriction_columns -> show_restriction_columns:   boolean  "'Show column'"
+Space|SpaceProperties.align -> align:   enum  "'Arrangement of the panels'"
+Space|SpaceProperties.brush_texture -> show_brush_texture:   boolean  "'Show brush textures'"
+Space|SpaceProperties.context -> context:   enum  "'Type of active data to display and edit'"
+Space|SpaceProperties.pin_id -> pin_id:   pointer  "'NO DESCRIPTION'"
+Space|SpaceProperties.use_pin_id -> use_pin_id:   boolean  "'Use the pinned context'"
+Space|SpaceSequenceEditor.display_channel -> display_channel:   int  "'The channel number shown in the image preview. 0 is the result of all strips combined'"
+Space|SpaceSequenceEditor.display_mode -> display_mode:   enum  "'The view mode to use for displaying sequencer output'"
+Space|SpaceSequenceEditor.draw_frames -> show_frames:   boolean  "'Draw frames rather than seconds'"
+Space|SpaceSequenceEditor.draw_overexposed -> draw_overexposed:   int  "'Show overexposed areas with zebra stripes'"
+Space|SpaceSequenceEditor.draw_safe_margin -> show_safe_margin:   boolean  "'Draw title safe margins in preview'"
+Space|SpaceSequenceEditor.grease_pencil -> grease_pencil:   pointer,  "'(read-only)    Grease pencil data for this space'"
+Space|SpaceSequenceEditor.offset_x -> offset_x:   float  "'Offsets image horizontally from the view center'"
+Space|SpaceSequenceEditor.offset_y -> offset_y:   float  "'Offsets image horizontally from the view center'"
+Space|SpaceSequenceEditor.proxy_render_size -> proxy_render_size:   enum  "'Draw preview using full resolution or different proxy resolutions'"
+Space|SpaceSequenceEditor.separate_color_preview -> show_separate_color:   boolean  "'Separate color channels in preview'"
+Space|SpaceSequenceEditor.show_cframe_indicator -> show_frame_indicator:   boolean  "'Show frame number beside the current frame indicator line'"
+Space|SpaceSequenceEditor.use_grease_pencil -> use_grease_pencil:   boolean  "'Display and edit the grease pencil freehand annotations overlay'"
+Space|SpaceSequenceEditor.use_marker_sync -> use_marker_sync:   boolean  "'Transform markers as well as strips'"
+Space|SpaceSequenceEditor.view_type -> view_type:   enum  "'The type of the Sequencer view (sequencer, preview or both)'"
+Space|SpaceSequenceEditor.zoom -> zoom:   float  "'Display zoom level'"
+Space|SpaceTextEditor.find_all -> use_find_all:   boolean  "'Search in all text datablocks, instead of only the active one'"
+Space|SpaceTextEditor.find_text -> find_text:   string  "'Text to search for with the find tool'"
+Space|SpaceTextEditor.find_wrap -> use_find_wrap:   boolean  "'Search again from the start of the file when reaching the end'"
+Space|SpaceTextEditor.font_size -> font_size:   int  "'Font size to use for displaying the text'"
+Space|SpaceTextEditor.line_numbers -> show_line_numbers:   boolean  "'Show line numbers next to the text'"
+Space|SpaceTextEditor.live_edit -> use_live_edit:   boolean  "'Run python while editing'"
+Space|SpaceTextEditor.overwrite -> use_overwrite:   boolean  "'Overwrite characters when typing rather than inserting them'"
+Space|SpaceTextEditor.replace_text -> replace_text:   string  "'Text to replace selected text with using the replace tool'"
+Space|SpaceTextEditor.syntax_highlight -> show_syntax_highlight:   boolean  "'Syntax highlight for scripting'"
+Space|SpaceTextEditor.tab_width -> tab_width:   int  "'Number of spaces to display tabs with'"
+Space|SpaceTextEditor.text -> text:   pointer  "'Text displayed and edited in this space'"
+Space|SpaceTextEditor.word_wrap -> use_word_wrap:   boolean  "'Wrap words if there is not enough horizontal space'"
+Space|SpaceTimeline.cache_cloth -> cache_cloth:   boolean  '"Show the active object\'s cloth point cache"'
+Space|SpaceTimeline.cache_particles -> cache_particles:   boolean  '"Show the active object\'s particle point cache"'
+Space|SpaceTimeline.cache_smoke -> cache_smoke:   boolean  '"Show the active object\'s smoke cache"'
+Space|SpaceTimeline.cache_softbody -> cache_softbody:   boolean  '"Show the active object\'s softbody point cache"'
+Space|SpaceTimeline.only_selected -> show_only_selected:   boolean  "'Show keyframes for active Object and/or its selected channels only'"
+Space|SpaceTimeline.play_all_3d -> use_play_3d_editors:   boolean  "'NO DESCRIPTION'"
+Space|SpaceTimeline.play_anim -> use_play_animation_editors:   boolean  "'NO DESCRIPTION'"
+Space|SpaceTimeline.play_buttons -> use_play_properties_editors:   boolean  "'NO DESCRIPTION'"
+Space|SpaceTimeline.play_image -> use_play_image_editors:   boolean  "'NO DESCRIPTION'"
+Space|SpaceTimeline.play_nodes -> use_play_node_editors:   boolean  "'NO DESCRIPTION'"
+Space|SpaceTimeline.play_sequencer -> use_play_sequence_editors:   boolean  "'NO DESCRIPTION'"
+Space|SpaceTimeline.play_top_left -> use_play_top_left_3d_editor:   boolean  "'NO DESCRIPTION'"
+Space|SpaceTimeline.show_cache -> show_cache:   boolean  "'Show the status of cached frames in the timeline'"
+Space|SpaceTimeline.show_cframe_indicator -> show_frame_indicator:   boolean  "'Show frame number beside the current frame indicator line'"
+Space|SpaceUserPreferences.filter -> filter:   string  "'Search term for filtering in the UI'"
+Space|SpaceView3D.all_object_origins -> show_all_objects_origin:   boolean  "'Show the object origin center dot for all (selected and unselected) objects'"
+Space|SpaceView3D.background_images -> background_images:   collection,  "'(read-only)    List of background images'"
+Space|SpaceView3D.camera -> camera:   pointer  '"Active camera used in this view (when unlocked from the scene\'s active camera)"'
+Space|SpaceView3D.clip_end -> clip_end:   float  "'3D View far clipping distance'"
+Space|SpaceView3D.clip_start -> clip_start:   float  "'3D View near clipping distance'"
+Space|SpaceView3D.current_orientation -> current_orientation:   pointer,  "'(read-only)    Current Transformation orientation'"
+Space|SpaceView3D.cursor_location -> cursor_location:   float  "'3D cursor location for this view (dependent on local view setting)'"
+Space|SpaceView3D.display_background_images -> show_background_images:   boolean  "'Display reference images behind objects in the 3D View'"
+Space|SpaceView3D.display_floor -> show_floor:   boolean  "'Show the ground plane grid in perspective view'"
+Space|SpaceView3D.display_render_override -> show_only_render:   boolean  "'Display only objects which will be rendered'"
+Space|SpaceView3D.display_x_axis -> show_axis_x:   boolean  "'Show the X axis line in perspective view'"
+Space|SpaceView3D.display_y_axis -> show_axis_y:   boolean  "'Show the Y axis line in perspective view'"
+Space|SpaceView3D.display_z_axis -> show_axis_z:   boolean  "'Show the Z axis line in perspective view'"
+Space|SpaceView3D.grid_lines -> grid_lines:   int  "'The number of grid lines to display in perspective view'"
+Space|SpaceView3D.grid_spacing -> grid_spacing:   float  "'The distance between 3D View grid lines'"
+Space|SpaceView3D.grid_subdivisions -> grid_subdivisions:   int  "'The number of subdivisions between grid lines'"
+Space|SpaceView3D.layers -> layers:   boolean  "'Layers visible in this 3D View'"
+Space|SpaceView3D.lens -> lens:   float  "'Lens angle (mm) in perspective view'"
+Space|SpaceView3D.local_view -> local_view:   pointer,  "'(read-only) &nbs