Bugfix #24335
[blender.git] / source / blender / makesrna / rna_cleanup / rna_properties.txt
index 18f6af118768ebb0e05ef8c4c0aa628ba26c5c24..df833d8e82ba1a7aeab714fabe46df4e51796d50 100644 (file)
 #+ * BoneGroup.color_set -> color_set:   enum  "Custom color set to use"
 #+ * BoneGroup.colors -> colors:   pointer,  "(read-only)    Copy of the colors associated with the groups color set"
 #+ * BoneGroup.name -> name:   string  "NO DESCRIPTION"
+#BoneGroups.active -> active:   pointer  "Active bone group for this pose"
 #+ * ClothCollisionSettings.collision_quality -> collision_quality:   int  "How many collision iterations should be done. (higher is better quality but slower)"
 #ClothCollisionSettings.distance_min -> distance_min:   float  "Minimum distance between collision objects before collision response takes in"
 #+ * ClothCollisionSettings.friction -> friction:   float  "Friction force if a collision happened. (higher = less movement)"
 #Constraint.error_rotation -> error_rotation:   float,  "(read-only)    Amount of residual error in radiant for constraints that work on orientation"
 #+ * Constraint.influence -> influence:   float  "Amount of influence constraint will have on the final solution"
 #Constraint.is_proxy_local -> is_proxy_local:   boolean  "Constraint was added in this proxy instance (i.e. did not belong to source Armature)"
- + * Constraint.disabled -> is_valid:   boolean,  "(read-only)    Constraint has invalid settings and will not be evaluated"
+#Constraint.is_valid -> is_valid:   boolean,  "(read-only)    Constraint has invalid settings and will not be evaluated"
 #+ * Constraint.mute -> mute:   boolean  "Enable/Disable Constraint"
 #+ * Constraint.name -> name:   string  "Constraint name"
 #+ * Constraint.owner_space -> owner_space:   enum  "Space that owner is evaluated in"
 #+ * Constraint|ChildOfConstraint.use_scale_z -> use_scale_z:   boolean  "Use Z Scale of Parent"
 #+ * Constraint|ClampToConstraint.main_axis -> main_axis:   enum  "Main axis of movement"
 #+ * Constraint|ClampToConstraint.target -> target:   pointer  "Target Object"
- + * Constraint|ClampToConstraint.cyclic -> use_cyclic:   boolean  "Treat curve as cyclic curve (no clamping to curve bounding box"
+#Constraint|ClampToConstraint.use_cyclic -> use_cyclic:   boolean  "Treat curve as cyclic curve (no clamping to curve bounding box"
 #+ * 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|CopyTransformsConstraint.target -> target:   pointer  "Target Object"
 #+ * Constraint|DampedTrackConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
 #+ * Constraint|DampedTrackConstraint.target -> target:   pointer  "Target Object"
- + * Constraint|DampedTrackConstraint.track -> track_axis:   enum  "Axis that points to the target object"
+#Constraint|DampedTrackConstraint.track_axis -> track_axis:   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.subtarget -> subtarget:   string  "NO DESCRIPTION"
 #+ * Constraint|FloorConstraint.target -> target:   pointer  "Target Object"
 #+ * Constraint|FloorConstraint.use_rotation -> use_rotation:   boolean  "Use the targets rotation to determine floor"
- + * Constraint|FloorConstraint.sticky -> use_sticky:   boolean  "Immobilize object while constrained"
- + * Constraint|FollowPathConstraint.forward -> forward_axis:   enum  "Axis that points forward along the path"
+#Constraint|FloorConstraint.use_sticky -> use_sticky:   boolean  "Immobilize object while constrained"
+#Constraint|FollowPathConstraint.forward_axis -> forward_axis:   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_axis:   enum  "Axis that points upward"
+#Constraint|FollowPathConstraint.up_axis -> up_axis:   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_location -> use_fixed_location:   boolean  "Object will stay locked to a single point somewhere along the length of the curve regardless of time"
 #Constraint|LimitScaleConstraint.use_min_y -> use_min_y:   boolean  "Use the minimum Y value"
 #Constraint|LimitScaleConstraint.use_min_z -> use_min_z:   boolean  "Use the minimum Z value"
 #Constraint|LimitScaleConstraint.use_transform_limit -> use_transform_limit:   boolean  "Transforms are affected by this constraint as well"
- + * Constraint|LockedTrackConstraint.lock -> lock_axis:   enum  "Axis that points upward"
+#Constraint|LockedTrackConstraint.lock_axis -> lock_axis:   enum  "Axis that points upward"
 #+ * Constraint|LockedTrackConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
 #+ * Constraint|LockedTrackConstraint.target -> target:   pointer  "Target Object"
- + * Constraint|LockedTrackConstraint.track -> track_axis:   enum  "Axis that points to the target object"
- + * Constraint|MaintainVolumeConstraint.axis -> free_axis:   enum  "The free scaling axis of the object"
+#Constraint|LockedTrackConstraint.track_axis -> track_axis:   enum  "Axis that points to the target object"
+#Constraint|MaintainVolumeConstraint.free_axis -> free_axis:   enum  "The free scaling axis of the object"
 #+ * Constraint|MaintainVolumeConstraint.volume -> volume:   float  "Volume of the bone at rest"
 #+ * Constraint|PivotConstraint.head_tail -> head_tail:   float  "Target along length of bone: Head=0, Tail=1"
 #+ * Constraint|PivotConstraint.offset -> offset:   float[3]  "Offset of pivot from target (when set), or from owners location (when Fixed Position is off), or the absolute pivot point"
 #+ * 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.track -> track_axis:   enum  "Axis that points to the target object"
- + * Constraint|TrackToConstraint.up -> up_axis:   enum  "Axis that points upward"
+#Constraint|TrackToConstraint.track_axis -> track_axis:   enum  "Axis that points to the target object"
+#Constraint|TrackToConstraint.up_axis -> up_axis:   enum  "Axis that points upward"
 #Constraint|TrackToConstraint.use_target_z -> use_target_z:   boolean  "Targets Z axis, not World Z axis, will constraint the Up direction"
 #+ * 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"
 #+ * CurveMapping.curves -> curves:   collection,  "(read-only)"
 #CurveMapping.use_clip -> use_clip:   boolean  "Force the curve view to fit a defined boundary"
 #+ * CurveMapping.white_level -> white_level:   float[3]  "For RGB curves, the color that white is mapped to"
-#TODO MOVE TO COLLECTION * CurveSplines.active -> active:   pointer  "Active curve spline"
+#+ * CurveSplines.active -> active:   pointer  "Active curve spline"
 #DopeSheet.filter_group -> filter_group:   pointer  "Group that included Object should be a member of"
 #DopeSheet.show_armatures -> show_armatures:   boolean  "Include visualization of Armature related Animation data"
 #DopeSheet.show_cameras -> show_cameras:   boolean  "Include visualization of Camera related Animation data"
 #GameObjectSettings.velocity_max -> velocity_max:   float  "Clamp velocity to this maximum speed"
 #GameObjectSettings.velocity_min -> velocity_min:   float  "Clamp velocity to this minimum speed (except when totally still)"
 #+ * GameProperty.name -> name:   string  "Available as GameObject attributes in the game engines python API"
- + * GameProperty.debug -> show_debug:   boolean  "Print debug information for this property"
+#GameProperty.show_debug -> show_debug:   boolean  "Print debug information for this property"
 #+ * GameProperty.type -> type:   enum  "NO DESCRIPTION"
 #+ * GameProperty|GameBooleanProperty.value -> value:   boolean  "Property value"
 #+ * GameProperty|GameFloatProperty.value -> value:   float  "Property value"
 #ID|Image.use_clamp_y -> use_clamp_y:   boolean  "Disable texture repeating vertically"
 #ID|Image.use_fields -> use_fields:   boolean  "Use fields of the image"
 #ID|Image.use_premultiply -> use_premultiply:   boolean  "Convert RGB from key alpha to premultiplied alpha"
- + * ID|Image.tiles -> use_tiles:   boolean  "Use of tilemode for faces (default shift-LMB to pick the tile for selected faces)"
+#ID|Image.use_tiles -> use_tiles:   boolean  "Use of tilemode for faces (default shift-LMB to pick the tile for selected faces)"
 #+ * 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|Lamp.energy -> energy:   float  "Amount of light that the lamp emits"
 #+ * 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.diffuse -> use_diffuse:   boolean  "Lamp does diffuse shading"
- + * ID|Lamp.negative -> use_negative:   boolean  "Lamp casts negative light"
- + * ID|Lamp.layer -> use_own_layer:   boolean  "Illuminates objects only on the same layer the lamp is on"
- + * ID|Lamp.specular -> use_specular:   boolean  "Lamp creates specular highlights"
+#ID|Lamp.use_diffuse -> use_diffuse:   boolean  "Lamp does diffuse shading"
+#ID|Lamp.use_negative -> use_negative:   boolean  "Lamp casts negative light"
+#ID|Lamp.use_own_layer -> use_own_layer:   boolean  "Illuminates objects only on the same layer the lamp is on"
+#ID|Lamp.use_specular -> use_specular:   boolean  "Lamp creates specular highlights"
 #+ * ID|Lamp|AreaLamp.gamma -> gamma:   float  "Light gamma correction value"
 #+ * ID|Lamp|AreaLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:   float  "Threshold for Adaptive Sampling (Raytraced shadows)"
 #+ * ID|Lamp|AreaLamp.shadow_color -> shadow_color:   float[3]  "Color of shadows cast by the lamp"
 #+ * 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.dither -> use_dither:   boolean  "Use 2x2 dithering for sampling  (Constant Jittered sampling)"
- + * ID|Lamp|AreaLamp.jitter -> use_jitter:   boolean  "Use noise for sampling  (Constant Jittered sampling)"
+#ID|Lamp|AreaLamp.use_dither -> use_dither:   boolean  "Use 2x2 dithering for sampling  (Constant Jittered sampling)"
+#ID|Lamp|AreaLamp.use_jitter -> use_jitter:   boolean  "Use noise for sampling  (Constant Jittered sampling)"
 #ID|Lamp|AreaLamp.use_only_shadow -> use_only_shadow:   boolean  "Causes light to cast shadows only without illuminating objects"
 #ID|Lamp|AreaLamp.use_shadow_layer -> use_shadow_layer:   boolean  "Causes only objects on the same layer to cast shadows"
 #ID|Lamp|AreaLamp.use_umbra -> use_umbra:   boolean  "Emphasize parts that are fully shadowed (Constant Jittered sampling)"
 #ID|Lamp|SpotLamp.use_only_shadow -> use_only_shadow:   boolean  "Causes light to cast shadows only without illuminating objects"
 #ID|Lamp|SpotLamp.use_shadow_layer -> use_shadow_layer:   boolean  "Causes only objects on the same layer to cast shadows"
 #ID|Lamp|SpotLamp.use_sphere -> use_sphere:   boolean  "Sets light intensity to zero beyond lamp distance"
- + * ID|Lamp|SpotLamp.square -> use_square:   boolean  "Casts a square spot light shape"
+#ID|Lamp|SpotLamp.use_square -> use_square:   boolean  "Casts a square spot light shape"
 #+ * ID|Lamp|SunLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:   float  "Threshold for Adaptive Sampling (Raytraced shadows)"
 #+ * ID|Lamp|SunLamp.shadow_color -> shadow_color:   float[3]  "Color of shadows cast by the lamp"
 #+ * ID|Lamp|SunLamp.shadow_method -> shadow_method:   enum  "Method to compute lamp shadow with"
 #ID|Material.use_cast_approximate -> use_cast_approximate:   boolean  "Allow this material to cast shadows when using approximate ambient occlusion."
 #ID|Material.use_cast_buffer_shadows -> use_cast_buffer_shadows:   boolean  "Allow this material to cast shadows from shadow buffer lamps"
 #ID|Material.use_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.use_cubic -> use_cubic:   boolean  "Use cubic interpolation for diffuse values, for smoother transitions"
 #+ * ID|Material.use_diffuse_ramp -> use_diffuse_ramp:   boolean  "Toggle diffuse ramp operations"
 #ID|Material.use_face_texture -> use_face_texture:   boolean  "Replaces the objects base color with color from face assigned image textures"
 #ID|Material.use_face_texture_alpha -> use_face_texture_alpha:   boolean  "Replaces the objects base alpha value with alpha from face assigned image textures"
 #ID|Material.use_ray_shadow_bias -> use_ray_shadow_bias:   boolean  "Prevents raytraced shadow errors on surfaces with smooth shaded normals (terminator problem)"
 #ID|Material.use_raytrace -> use_raytrace:   boolean  "Include this material and geometry that uses it in ray tracing calculations"
 #ID|Material.use_shadeless -> use_shadeless:   boolean  "Makes this material insensitive to light or shadow"
- + * ID|Material.shadows -> use_shadows:   boolean  "Allows this material to receive shadows"
+#ID|Material.use_shadows -> use_shadows:   boolean  "Allows this material to receive shadows"
 #+ * 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_tangent_shading -> use_tangent_shading:   boolean  "Use the materials tangent vector instead of the normal for shading - for anisotropic shading effects"
 #ID|Material.use_vertex_color_light -> use_vertex_color_light:   boolean  "Add vertex colors as additional lighting"
 #ID|Material.use_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|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.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
 #ID|Mesh.auto_smooth_angle -> auto_smooth_angle:   int  "Defines maximum angle between face normals that Auto Smooth will operate on"
 #+ * ID|Mesh.uv_textures -> uv_textures:   collection,  "(read-only)"
 #+ * ID|Mesh.vertex_colors -> vertex_colors:   collection,  "(read-only)"
 #ID|Mesh.vertices -> vertices:   collection,  "(read-only)    Vertices of the mesh"
-#TODO MOVE TO ELEMENTS * 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.elements -> elements:   collection,  "(read-only)    Meta elements"
 #+ * ID|MetaBall.materials -> materials:   collection,  "(read-only)"
 #+ * ID|ParticleSettings.child_type -> child_type:   enum  "Create child particles"
 #+ * ID|ParticleSettings.clump_factor -> clump_factor:   float  "Amount of clumping"
 #ID|ParticleSettings.clump_shape -> clump_shape:   float  "Shape of clumping"
- + * ID|ParticleSettings.amount -> count:   int  "Total number of particles"
+#ID|ParticleSettings.count -> count:   int  "Total number of particles"
 #ID|ParticleSettings.damping -> damping:   float  "Specify the amount of damping"
 #+ * 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_method -> draw_method:   enum  "How particles are drawn in viewport"
- + * ID|ParticleSettings.display -> draw_percentage:   int  "Percentage of particles to display in 3D view"
+#ID|ParticleSettings.draw_percentage -> draw_percentage:   int  "Percentage of particles to display in 3D view"
 #+ * 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.show_number -> show_number:   boolean  "Show particle number"
 #+ * ID|ParticleSettings.show_size -> show_size:   boolean  "Show particle size"
 #ID|ParticleSettings.show_unborn -> show_unborn:   boolean  "Show particles before they are emitted"
- + * ID|ParticleSettings.velocity -> show_velocity:   boolean  "Show particle velocity"
+#ID|ParticleSettings.show_velocity -> show_velocity:   boolean  "Show particle velocity"
 #+ * 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.use_dead -> use_dead:   boolean  "Show particles after they have died"
 #ID|ParticleSettings.use_die_on_collision -> use_die_on_collision:   boolean  "Particles die when they collide with a deflector object"
 #ID|ParticleSettings.use_dynamic_rotation -> use_dynamic_rotation:   boolean  "Sets rotation to dynamic/constant"
- + * ID|ParticleSettings.trand -> use_emit_random:   boolean  "Emit in random order of elements"
+#ID|ParticleSettings.use_emit_random -> use_emit_random:   boolean  "Emit in random order of elements"
 #ID|ParticleSettings.use_even_distribution -> use_even_distribution:   boolean  "Use even distribution from faces based on face areas or edge lengths"
 #+ * ID|ParticleSettings.use_global_dupli -> use_global_dupli:   boolean  "Use objects global coordinates for duplication"
 #+ * ID|ParticleSettings.use_group_count -> use_group_count:   boolean  "Use object multiple times in the same group"
 #ID|ParticleSettings.use_group_pick_random -> use_group_pick_random:   boolean  "Pick objects from group randomly"
 #ID|ParticleSettings.use_hair_bspline -> use_hair_bspline:   boolean  "Interpolate hair using B-Splines"
 #ID|ParticleSettings.use_multiply_size_mass -> use_multiply_size_mass:   boolean  "Multiply mass by particle size"
- + * ID|ParticleSettings.parent -> use_parent_particles:   boolean  "Render parent particles"
+#ID|ParticleSettings.use_parent_particles -> use_parent_particles:   boolean  "Render parent particles"
 #ID|ParticleSettings.use_react_multiple -> use_react_multiple:   boolean  "React multiple times"
 #ID|ParticleSettings.use_react_start_end -> use_react_start_end:   boolean  "Give birth to unreacted particles eventually"
 #ID|ParticleSettings.use_render_adaptive -> use_render_adaptive:   boolean  "Draw steps of the particle path"
- + * ID|ParticleSettings.emitter -> use_render_emitter:   boolean  "Render emitter Object also"
+#ID|ParticleSettings.use_render_emitter -> use_render_emitter:   boolean  "Render emitter Object also"
 #ID|ParticleSettings.use_self_effect -> use_self_effect:   boolean  "Particle effectors effect themselves"
 #ID|ParticleSettings.use_simplify -> use_simplify:   boolean  "Remove child strands as the object becomes smaller on the screen"
- + * ID|ParticleSettings.viewport -> use_simplify_viewport:   boolean  "NO DESCRIPTION"
+#ID|ParticleSettings.use_simplify_viewport -> use_simplify_viewport:   boolean  "NO DESCRIPTION"
 #ID|ParticleSettings.use_size_deflect -> use_size_deflect:   boolean  "Use particles size in deflection"
 #ID|ParticleSettings.use_strand_primitive -> use_strand_primitive:   boolean  "Use the strand primitive for rendering"
 #ID|ParticleSettings.use_symmetric_branching -> use_symmetric_branching:   boolean  "Start and end points are the same"
 #ID|ParticleSettings.use_whole_group -> use_whole_group:   boolean  "Use whole group at once"
 #+ * ID|ParticleSettings.userjit -> userjit:   int  "Emission locations / face (0 = automatic)"
 #+ * ID|ParticleSettings.virtual_parents -> virtual_parents:   float  "Relative amount of virtual parents"
-#+ * 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.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
 #ID|Scene.audio_distance_model -> audio_distance_model:   enum  "Distance model for distance attenuation calculation"
 #+TODO MAKE COLOR * ID|Texture.factor_blue -> factor_blue:   float  "NO DESCRIPTION"
 #+TODO MAKE COLOR * ID|Texture.factor_green -> factor_green:   float  "NO DESCRIPTION"
 #+TODO MAKE COLOR * ID|Texture.factor_red -> factor_red:   float  "NO DESCRIPTION"
- + * ID|Texture.brightness -> intensity:   float  "NO DESCRIPTION"
+#ID|Texture.intensity -> intensity:   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_preview_alpha -> use_preview_alpha:   boolean  "Show Alpha in Preview Render"
 #+ * ID|Texture|BlendTexture.progression -> progression:   enum  "Sets the style of the color blending"
 #ID|Texture|BlendTexture.use_flip_axis -> use_flip_axis:   enum  "Flips the textures X and Y axis"
- + * ID|Texture|CloudsTexture.stype -> cloud_type:   enum  "NO DESCRIPTION"
+#ID|Texture|CloudsTexture.cloud_type -> cloud_type:   enum  "NO DESCRIPTION"
 #+ * 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|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 -> filter_type:   enum  "Texture filter to use for sampling image"
+#ID|Texture|EnvironmentMapTexture.filter_type -> filter_type:   enum  "Texture filter to use for sampling image"
 #+ * 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.use_filter_size_min -> use_filter_size_min:   boolean  "Use Filter Size as a minimal filter value in pixels"
- + * ID|Texture|EnvironmentMapTexture.mipmap -> use_mipmap:   boolean  "Uses auto-generated MIP maps for the image"
+#ID|Texture|EnvironmentMapTexture.use_mipmap -> use_mipmap:   boolean  "Uses auto-generated MIP maps for the image"
 #ID|Texture|EnvironmentMapTexture.use_mipmap_gauss -> use_mipmap_gauss:   boolean  "Uses Gauss filter to sample down MIP maps"
 #+ * ID|Texture|ImageTexture.checker_distance -> checker_distance:   float  "Sets distance between checker tiles"
 #+ * ID|Texture|ImageTexture.crop_max_x -> crop_max_x:   float  "Sets maximum X value to crop the 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 -> filter_type:   enum  "Texture filter to use for sampling image"
+#ID|Texture|ImageTexture.filter_type -> filter_type:   enum  "Texture filter to use for sampling image"
 #+ * 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.invert_alpha -> invert_alpha:   boolean  "Inverts all the alpha values in the image"
 #ID|Texture|ImageTexture.use_checker_odd -> use_checker_odd:   boolean  "Sets odd checker tiles"
 #ID|Texture|ImageTexture.use_filter_size_min -> use_filter_size_min:   boolean  "Use Filter Size as a minimal filter value in pixels"
 #ID|Texture|ImageTexture.use_flip_axis -> use_flip_axis:   boolean  "Flips the textures X and Y axis"
- + * ID|Texture|ImageTexture.interpolation -> use_interpolation:   boolean  "Interpolates pixels using Area filter"
- + * ID|Texture|ImageTexture.mipmap -> use_mipmap:   boolean  "Uses auto-generated MIP maps for the image"
+#ID|Texture|ImageTexture.use_interpolation -> use_interpolation:   boolean  "Interpolates pixels using Area filter"
+#ID|Texture|ImageTexture.use_mipmap -> use_mipmap:   boolean  "Uses auto-generated MIP maps for the image"
 #ID|Texture|ImageTexture.use_mipmap_gauss -> use_mipmap_gauss:   boolean  "Uses Gauss filter to sample down MIP maps"
 #ID|Texture|ImageTexture.use_mirror_x -> use_mirror_x:   boolean  "Mirrors the image repetition on the X direction"
 #ID|Texture|ImageTexture.use_mirror_y -> use_mirror_y:   boolean  "Mirrors the image repetition on the Y direction"
 #ID|Texture|ImageTexture.use_normal_map -> use_normal_map:   boolean  "Uses image RGB values for normal mapping"
 #+ * 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.stype -> marble_type:   enum  "NO DESCRIPTION"
+#ID|Texture|MarbleTexture.marble_type -> marble_type:   enum  "NO DESCRIPTION"
 #+ * 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|StucciTexture.noise_basis -> noise_basis:   enum  "Sets the noise basis used for turbulence"
 #ID|Texture|StucciTexture.noise_scale -> noise_scale:   float  "Sets scaling for noise input"
 #+ * ID|Texture|StucciTexture.noise_type -> noise_type:   enum  "NO DESCRIPTION"
- + * ID|Texture|StucciTexture.stype -> stucci_type:   enum  "NO DESCRIPTION"
+#ID|Texture|StucciTexture.stucci_type -> stucci_type:   enum  "NO DESCRIPTION"
 #+ * ID|Texture|StucciTexture.turbulence -> turbulence:   float  "Sets the turbulence of the bandnoise and ringnoise types"
 #ID|Texture|VoronoiTexture.color_mode -> color_mode:   enum  "NO DESCRIPTION"
 #+ * ID|Texture|VoronoiTexture.distance_metric -> distance_metric:   enum  "NO DESCRIPTION"
 #+ * ID|Texture|WoodTexture.noise_type -> noise_type:   enum  "NO DESCRIPTION"
 #ID|Texture|WoodTexture.noisebasis_2 -> noisebasis_2:   enum  "NO DESCRIPTION"
 #+ * ID|Texture|WoodTexture.turbulence -> turbulence:   float  "Sets the turbulence of the bandnoise and ringnoise types"
- + * ID|Texture|WoodTexture.stype -> wood_type:   enum  "NO DESCRIPTION"
+#ID|Texture|WoodTexture.wood_type -> wood_type:   enum  "NO DESCRIPTION"
 #+ * ID|VectorFont.filepath -> filepath:   string,  "(read-only)"
 #+ * ID|VectorFont.packed_file -> packed_file:   pointer,  "(read-only)"
-#TODO, move into collectin * 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_index -> active_texture_index:   int  "Index of active texture slot"
 #+ * ID|World.ambient_color -> ambient_color:   float[3]  "NO DESCRIPTION"
 #+ * ID|World.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
- + * ID|World.range -> color_range:   float  "The color range that will be mapped to 0-1"
+#ID|World.color_range -> color_range:   float  "The color range that will be mapped to 0-1"
 #+ * ID|World.exposure -> exposure:   float  "Amount of exponential color correction for light"
 #+ * ID|World.horizon_color -> horizon_color:   float[3]  "Color at the horizon"
- + * ID|World.lighting -> light_settings:   pointer,  "(read-only)    World lighting settings"
- + * ID|World.mist -> mist_settings:   pointer,  "(read-only)    World mist settings"
- + * ID|World.stars -> star_settings:   pointer,  "(read-only)    World stars settings"
+#ID|World.light_settings -> light_settings:   pointer,  "(read-only)    World lighting settings"
+#ID|World.mist_settings -> mist_settings:   pointer,  "(read-only)    World mist settings"
+#ID|World.star_settings -> star_settings:   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.use_sky_blend -> use_sky_blend:   boolean  "Render background with natural progression from horizon to zenith"
 #ID|World.use_sky_paper -> use_sky_paper:   boolean  "Flatten blend or texture coordinates"
 #IKParam|Itasc.use_auto_step -> use_auto_step:   boolean  "Automatically determine the optimal number of steps for best performance/accuracy trade off"
 #IKParam|Itasc.velocity_max -> velocity_max:   float  "Maximum joint velocity in rad/s. Default=50"
 #+ * ImageUser.fields_per_frame -> fields_per_frame:   int  "The number of fields per rendered frame (2 fields is 1 image)"
- + * ImageUser.frames -> frame_duration:   int  "Sets the number of images of a movie to use"
- + * ImageUser.offset -> frame_offset:   int  "Offsets the number of the frame to use in the animation"
+#ImageUser.frame_duration -> frame_duration:   int  "Sets the number of images of a movie to use"
+#ImageUser.frame_offset -> frame_offset:   int  "Offsets the number of the frame to use in the animation"
 #+ * ImageUser.frame_start -> frame_start:   int  "Sets the global starting frame of the movie"
 #+ * 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.use_auto_refresh -> use_auto_refresh:   boolean  "Always refresh image on frame changes"
- + * ImageUser.cyclic -> use_cyclic:   boolean  "Cycle the images in the movie"
+#ImageUser.use_cyclic -> use_cyclic:   boolean  "Cycle the images in the movie"
 #KeyConfig.is_user_defined -> is_user_defined:   boolean,  "(read-only)    Indicates that a keyconfig was defined by the user"
 #+ * KeyConfig.keymaps -> keymaps:   collection,  "(read-only)    Key maps configured as part of this configuration"
 #+ * KeyConfig.name -> name:   string  "Name of the key configuration"
+#KeyConfigurations.active -> active:   pointer  "Active wm KeyConfig"
+#KeyConfigurations.default -> default:   pointer,  "(read-only)"
 #KeyMap.is_modal -> is_modal:   boolean,  "(read-only)    Indicates that a keymap is used for translate modal events for an operator"
 #KeyMap.is_user_defined -> is_user_defined:   boolean  "Keymap is defined by the user"
 #+ * KeyMap.items -> items:   collection,  "(read-only)    Items in the keymap, linking an operator to an input event"
 #+ * Keyframe.select_left_handle -> select_left_handle:   boolean  "Handle 1 selection status"
 #+ * Keyframe.select_right_handle -> select_right_handle:   boolean  "Handle 2 selection status"
 #+ * Keyframe.type -> type:   enum  "The type of keyframe"
-#TODO MOVE TO COLLECTION * KeyingSet.active_path -> active_path:   pointer  "Active Keying Set used to insert/delete keyframes"
 #+ * KeyingSet.active_path_index -> active_path_index:   int  "Current Keying Set index"
 #KeyingSet.is_path_absolute -> is_path_absolute:   boolean,  "(read-only)    Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)"
 #+ * KeyingSet.name -> name:   string  "NO DESCRIPTION"
 #KeyingSetPath.use_insertkey_needed -> use_insertkey_needed:   boolean  "Only insert keyframes where theyre needed in the relevant F-Curves"
 #KeyingSetPath.use_insertkey_visual -> use_insertkey_visual:   boolean  "Insert keyframes based on visual transforms"
 #KeyingSetPath.use_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"
+#KeyingSetPaths.active -> active:   pointer  "Active Keying Set used to insert/delete keyframes"
+#KeyingSets.active -> active:   pointer  "Active Keying Set used to insert/delete keyframes"
 #+ * LampSkySettings.atmosphere_distance_factor -> atmosphere_distance_factor:   float  "Multiplier to convert blender units to physical distance"
 #+ * LampSkySettings.atmosphere_extinction -> atmosphere_extinction:   float  "Extinction scattering contribution factor"
 #+ * LampSkySettings.atmosphere_inscattering -> atmosphere_inscattering:   float  "Scatter contribution factor"
 #+ * LampSkySettings.atmosphere_turbidity -> atmosphere_turbidity:   float  "Sky turbidity"
 #+ * LampSkySettings.backscattered_light -> backscattered_light:   float  "Backscattered light"
- + * LampSkySettings.horizon_brightness -> horizon_intensity:   float  "Horizon brightness"
+#+ * LampSkySettings.horizon_brightness -> horizon_brightness:   float  "Horizon brightness"
 #+ * LampSkySettings.sky_blend -> sky_blend:   float  "Blend factor with sky"
 #+ * LampSkySettings.sky_blend_type -> sky_blend_type:   enum  "Blend mode for combining sun sky with world sky"
 #+ * LampSkySettings.sky_color_space -> sky_color_space:   enum  "Color space to use for internal XYZ->RGB color conversion"
 #MaterialHalo.line_count -> line_count:   int  "Sets the number of star shaped lines rendered over the halo"
 #MaterialHalo.ring_count -> ring_count:   int  "Sets the number of rings rendered over the halo"
 #+ * MaterialHalo.seed -> seed:   int  "Randomizes ring dimension and line location"
-#MaterialHalo.show_shaded -> show_shaded:   boolean  "Lets halo receive light and shadows from external objects"
 #+ * MaterialHalo.size -> size:   float  "Sets the dimension of the halo"
 #MaterialHalo.star_tip_count -> star_tip_count:   int  "Sets the number of points on the star shaped halo"
 #MaterialHalo.use_extreme_alpha -> use_extreme_alpha:   boolean  "Uses extreme alpha"
 #MaterialHalo.use_flare_mode -> use_flare_mode:   boolean  "Renders halo as a lensflare"
- + * MaterialHalo.lines -> use_lines:   boolean  "Renders star shaped lines over halo"
- + * MaterialHalo.ring -> use_ring:   boolean  "Renders rings over halo"
- + * MaterialHalo.soft -> use_soft:   boolean  "Softens the edges of halos at intersections with other geometry"
- + * MaterialHalo.star -> use_star:   boolean  "Renders halo as a star"
- + * MaterialHalo.texture -> use_texture:   boolean  "Gives halo a texture"
+#MaterialHalo.use_lines -> use_lines:   boolean  "Renders star shaped lines over halo"
+#MaterialHalo.use_ring -> use_ring:   boolean  "Renders rings over halo"
+#MaterialHalo.use_shaded -> use_shaded:   boolean  "Lets halo receive light and shadows from external objects"
+#MaterialHalo.use_soft -> use_soft:   boolean  "Softens the edges of halos at intersections with other geometry"
+#MaterialHalo.use_star -> use_star:   boolean  "Renders halo as a star"
+#MaterialHalo.use_texture -> use_texture:   boolean  "Gives halo a texture"
 #MaterialHalo.use_vertex_normal -> use_vertex_normal:   boolean  "Uses the vertex normal to specify the dimension of the halo"
- + * MaterialPhysics.damp -> damping:   float  "Damping of the spring force, when inside the physics distance area"
+#MaterialPhysics.damping -> damping:   float  "Damping of the spring force, when inside the physics distance area"
 #+ * MaterialPhysics.distance -> distance:   float  "Distance of the physics area"
 #+ * MaterialPhysics.elasticity -> elasticity:   float  "Elasticity of collisions"
 #+ * MaterialPhysics.force -> force:   float  "Upward spring force, when inside the physics distance area"
 #+ * MaterialRaytraceMirror.reflect_factor -> reflect_factor:   float  "Sets the amount mirror reflection for raytrace"
 #+ * MaterialRaytraceMirror.use -> use:   boolean  "Enable raytraced reflections"
 #+ * MaterialRaytraceTransparency.depth -> depth:   int  "Maximum allowed number of light inter-refractions"
- + * MaterialRaytraceTransparency.limit -> depth_max:   float  "Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled)"
+#MaterialRaytraceTransparency.depth_max -> depth_max:   float  "Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled)"
 #+ * MaterialRaytraceTransparency.falloff -> falloff:   float  "Falloff power for transmissivity filter effect (1.0 is linear)"
 #+ * MaterialRaytraceTransparency.filter -> filter:   float  "Amount to blend in the materials diffuse color in raytraced transparency (simulating absorption)"
 #+ * MaterialRaytraceTransparency.fresnel -> fresnel:   float  "Power of Fresnel for transparency (Ray or ZTransp)"
 #+ * MeshVertex.index -> index:   int,  "(read-only)    Index number of the vertex"
 #+ * MeshVertex.normal -> normal:   float[3]  "Vertex Normal"
 #+ * MeshVertex.select -> select:   boolean  "NO DESCRIPTION"
+#MetaBallElements.active -> active:   pointer,  "(read-only)    Last selected element"
 #MetaElement.co -> co:   float[3]  "NO DESCRIPTION"
 #+ * MetaElement.hide -> hide:   boolean  "Hide element"
 #+ * MetaElement.radius -> radius:   float  "NO DESCRIPTION"
 #Modifier.show_render -> show_render:   boolean  "Use modifier during rendering"
 #Modifier.show_viewport -> show_viewport:   boolean  "Realtime display of a modifier"
 #+ * Modifier.type -> type:   enum,  "(read-only)"
- + * Modifier|ArmatureModifier.invert -> invert_vertex_group:   boolean  "Invert vertex group influence"
+#Modifier|ArmatureModifier.invert_vertex_group -> invert_vertex_group:   boolean  "Invert vertex group influence"
 #+ * Modifier|ArmatureModifier.object -> object:   pointer  "Armature object to deform with"
 #+ * Modifier|ArmatureModifier.use_bone_envelopes -> use_bone_envelopes:   boolean  "NO DESCRIPTION"
- + * Modifier|ArmatureModifier.quaternion -> use_deform_preserve_volume:   boolean  "Deform rotation interpolation with quaternions"
+#Modifier|ArmatureModifier.use_deform_preserve_volume -> use_deform_preserve_volume:   boolean  "Deform rotation interpolation with quaternions"
 #Modifier|ArmatureModifier.use_multi_modifier -> use_multi_modifier:   boolean  "Use same input as previous modifier, and mix results using overall vgroup"
 #+ * Modifier|ArmatureModifier.use_vertex_groups -> use_vertex_groups:   boolean  "NO DESCRIPTION"
 #+ * Modifier|ArmatureModifier.vertex_group -> vertex_group:   string  "Vertex group name"
 #+ * 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.length -> fit_length:   float  "Length to fit array within"
+#Modifier|ArrayModifier.fit_length -> fit_length:   float  "Length to fit array within"
 #+ * Modifier|ArrayModifier.fit_type -> fit_type:   enum  "Array length calculation method"
 #Modifier|ArrayModifier.merge_threshold -> merge_threshold:   float  "Limit below which to merge vertices"
 #+ * Modifier|ArrayModifier.offset_object -> offset_object:   pointer  "NO DESCRIPTION"
 #Modifier|ArrayModifier.use_merge_vertices_cap -> use_merge_vertices_cap:   boolean  "Merge vertices in first and last duplicates"
 #Modifier|ArrayModifier.use_object_offset -> use_object_offset:   boolean  "Add another objects transformation to the total offset"
 #Modifier|ArrayModifier.use_relative_offset -> use_relative_offset:   boolean  "Add an offset relative to the objects bounding box"
- + * Modifier|BevelModifier.angle -> angle_limit:   float  "Angle above which to bevel edges"
+#Modifier|BevelModifier.angle_limit -> 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.use_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.length -> frame_duration:   float  "Specify the total time the build effect requires"
+#Modifier|BuildModifier.frame_duration -> frame_duration:   float  "Specify the total time the build effect requires"
 #+ * Modifier|BuildModifier.frame_start -> frame_start:   float  "Specify the start frame of the effect"
 #+ * Modifier|BuildModifier.seed -> seed:   int  "Specify the seed for random if used"
- + * Modifier|BuildModifier.randomize -> use_random_order:   boolean  "Randomize the faces or edges during build"
+#Modifier|BuildModifier.use_random_order -> use_random_order:   boolean  "Randomize the faces or edges during build"
 #+ * Modifier|CastModifier.cast_type -> cast_type:   enum  "NO DESCRIPTION"
 #+ * Modifier|CastModifier.factor -> factor:   float  "NO DESCRIPTION"
 #+ * Modifier|CastModifier.object -> object:   pointer  "Control object: if available, its location determines the center of the effect"
 #+ * Modifier|CastModifier.size -> size:   float  "Size of projection shape (leave as 0 for auto.)"
 #Modifier|CastModifier.use_radius_as_size -> use_radius_as_size:   boolean  "Use radius as size of projection shape (0 = auto)"
 #+ * Modifier|CastModifier.use_transform -> use_transform:   boolean  "Use object transform to control projection shape"
- + * 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|CastModifier.use_x -> use_x:   boolean  "NO DESCRIPTION"
+#Modifier|CastModifier.use_y -> use_y:   boolean  "NO DESCRIPTION"
+#Modifier|CastModifier.use_z -> use_z:   boolean  "NO DESCRIPTION"
 #+ * Modifier|CastModifier.vertex_group -> vertex_group:   string  "Vertex group name"
 #+ * Modifier|ClothModifier.collision_settings -> collision_settings:   pointer,  "(read-only)"
 #+ * Modifier|ClothModifier.point_cache -> point_cache:   pointer,  "(read-only)"
 #Modifier|ExplodeModifier.show_dead -> show_dead:   boolean  "Show mesh when particles are dead"
 #Modifier|ExplodeModifier.show_unborn -> show_unborn:   boolean  "Show mesh when particles are unborn"
 #Modifier|ExplodeModifier.use_edge_split -> use_edge_split:   boolean  "Split face edges for nicer shrapnel"
- + * Modifier|ExplodeModifier.size -> use_size:   boolean  "Use particle size for the shrapnel"
+#Modifier|ExplodeModifier.use_size -> use_size:   boolean  "Use particle size for the shrapnel"
 #+ * 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|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.invert_vertex_group -> 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.invert -> invert_vertex_group:   boolean  "Invert vertex group influence"
+#Modifier|MeshDeformModifier.invert_vertex_group -> 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.dynamic -> use_dynamic_bind:   boolean  "Recompute binding dynamically on top of other deformers (slower and more memory consuming.)"
+#Modifier|MeshDeformModifier.use_dynamic_bind -> use_dynamic_bind:   boolean  "Recompute binding dynamically on top of other deformers (slower and more memory consuming.)"
 #+ * Modifier|MeshDeformModifier.vertex_group -> vertex_group:   string  "Vertex group name"
 #Modifier|MirrorModifier.merge_threshold -> merge_threshold:   float  "Distance from axis within which mirrored vertices are merged"
 #+ * Modifier|MirrorModifier.mirror_object -> mirror_object:   pointer  "Object to use as mirror"
- + * Modifier|MirrorModifier.clip -> use_clip:   boolean  "Prevents vertices from going through the mirror during transform"
+#Modifier|MirrorModifier.use_clip -> use_clip:   boolean  "Prevents vertices from going through the mirror during transform"
 #Modifier|MirrorModifier.use_mirror_u -> use_mirror_u:   boolean  "Mirror the U texture coordinate around the 0.5 point"
 #Modifier|MirrorModifier.use_mirror_v -> use_mirror_v:   boolean  "Mirror the V texture coordinate around the 0.5 point"
 #Modifier|MirrorModifier.use_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|MirrorModifier.use_x -> use_x:   boolean  "Enable X axis mirror"
+#Modifier|MirrorModifier.use_y -> use_y:   boolean  "Enable Y axis mirror"
+#Modifier|MirrorModifier.use_z -> use_z:   boolean  "Enable Z axis mirror"
 #+ * Modifier|MultiresModifier.filepath -> filepath:   string  "Path to external displacements file"
 #Modifier|MultiresModifier.is_external -> is_external:   boolean,  "(read-only)    Store multires displacements outside the .blend file, to save memory"
 #+ * Modifier|MultiresModifier.levels -> levels:   int  "Number of subdivisions to use in the viewport"
 #Modifier|ParticleInstanceModifier.show_alive -> show_alive:   boolean  "Show instances when particles are alive"
 #Modifier|ParticleInstanceModifier.show_dead -> show_dead:   boolean  "Show instances when particles are dead"
 #Modifier|ParticleInstanceModifier.show_unborn -> show_unborn:   boolean  "Show instances when particles are unborn"
- + * Modifier|ParticleInstanceModifier.children -> use_children:   boolean  "Create instances from child particles"
- + * Modifier|ParticleInstanceModifier.normal -> use_normal:   boolean  "Create instances from normal particles"
+#Modifier|ParticleInstanceModifier.use_children -> use_children:   boolean  "Create instances from child particles"
+#Modifier|ParticleInstanceModifier.use_normal -> use_normal:   boolean  "Create instances from normal particles"
 #+ * Modifier|ParticleInstanceModifier.use_path -> use_path:   boolean  "Create instances along particle paths"
 #Modifier|ParticleInstanceModifier.use_preserve_shape -> use_preserve_shape:   boolean  "Dont stretch the object"
- + * Modifier|ParticleInstanceModifier.size -> use_size:   boolean  "Use particle size to scale the instances"
+#Modifier|ParticleInstanceModifier.use_size -> use_size:   boolean  "Use particle size to scale the instances"
 #+ * 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|ShrinkwrapModifier.use_cull_back_faces -> use_cull_back_faces:   boolean  "Stop vertices from projecting to a back face on the target"
 #Modifier|ShrinkwrapModifier.use_cull_front_faces -> use_cull_front_faces:   boolean  "Stop vertices from projecting to a front face on the target"
 #Modifier|ShrinkwrapModifier.use_keep_above_surface -> use_keep_above_surface:   boolean  "NO DESCRIPTION"
- + * Modifier|ShrinkwrapModifier.negative -> use_negative_direction:   boolean  "Allow vertices to move in the negative direction of axis"
- + * Modifier|ShrinkwrapModifier.positive -> use_positive_direction:   boolean  "Allow vertices to move in the positive direction of axis"
- + * 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|ShrinkwrapModifier.use_negative_direction -> use_negative_direction:   boolean  "Allow vertices to move in the negative direction of axis"
+#Modifier|ShrinkwrapModifier.use_positive_direction -> use_positive_direction:   boolean  "Allow vertices to move in the positive direction of axis"
+#Modifier|ShrinkwrapModifier.use_project_x -> use_project_x:   boolean  "NO DESCRIPTION"
+#Modifier|ShrinkwrapModifier.use_project_y -> use_project_y:   boolean  "NO DESCRIPTION"
+#Modifier|ShrinkwrapModifier.use_project_z -> use_project_z:   boolean  "NO DESCRIPTION"
 #+ * Modifier|ShrinkwrapModifier.vertex_group -> vertex_group:   string  "Vertex group name"
- + * Modifier|ShrinkwrapModifier.mode -> wrap_method:   enum  "NO DESCRIPTION"
- + * Modifier|SimpleDeformModifier.mode -> deform_method:   enum  "NO DESCRIPTION"
+#Modifier|ShrinkwrapModifier.wrap_method -> wrap_method:   enum  "NO DESCRIPTION"
+#Modifier|SimpleDeformModifier.deform_method -> deform_method:   enum  "NO DESCRIPTION"
 #+ * Modifier|SimpleDeformModifier.factor -> factor:   float  "NO DESCRIPTION"
 #+ * Modifier|SimpleDeformModifier.limits -> limits:   float[2]  "Lower/Upper limits for deform"
 #Modifier|SimpleDeformModifier.lock_x -> lock_x:   boolean  "NO DESCRIPTION"
 #Modifier|SimpleDeformModifier.lock_y -> lock_y:   boolean  "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.use_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 -> iterations:   int  "NO DESCRIPTION"
- + * 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|SmoothModifier.iterations -> iterations:   int  "NO DESCRIPTION"
+#Modifier|SmoothModifier.use_x -> use_x:   boolean  "NO DESCRIPTION"
+#Modifier|SmoothModifier.use_y -> use_y:   boolean  "NO DESCRIPTION"
+#Modifier|SmoothModifier.use_z -> use_z:   boolean  "NO DESCRIPTION"
 #+ * Modifier|SmoothModifier.vertex_group -> vertex_group:   string  "Vertex group name"
 #+ * 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.invert_vertex_group -> invert_vertex_group:   boolean  "Invert the vertex group influence"
 #+ * Modifier|SolidifyModifier.offset -> offset:   float  "Offset the thickness from the center"
 #+ * 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|WaveModifier.texture_coords -> texture_coords:   enum  "Texture coordinates used for modulating input"
 #Modifier|WaveModifier.texture_coords_object -> texture_coords_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.cyclic -> use_cyclic:   boolean  "Cyclic wave effect"
- + * Modifier|WaveModifier.normals -> use_normal:   boolean  "Displace along normals"
+#Modifier|WaveModifier.use_cyclic -> use_cyclic:   boolean  "Cyclic wave effect"
+#Modifier|WaveModifier.use_normal -> use_normal:   boolean  "Displace along normals"
 #Modifier|WaveModifier.use_normal_x -> use_normal_x:   boolean  "Enable displacement along the X normal"
 #Modifier|WaveModifier.use_normal_y -> use_normal_y:   boolean  "Enable displacement along the Y normal"
 #Modifier|WaveModifier.use_normal_z -> use_normal_z:   boolean  "Enable displacement along the Z normal"
- + * Modifier|WaveModifier.x -> use_x:   boolean  "X axis motion"
- + * Modifier|WaveModifier.y -> use_y:   boolean  "Y axis motion"
+#Modifier|WaveModifier.use_x -> use_x:   boolean  "X axis motion"
+#Modifier|WaveModifier.use_y -> use_y:   boolean  "Y axis motion"
 #+ * 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"
 #NlaStrip.use_animated_time -> use_animated_time:   boolean  "Strip time is controlled by an F-Curve rather than automatically determined"
 #NlaStrip.use_animated_time_cyclic -> use_animated_time_cyclic:   boolean  "Cycle the animated time within the action start & end"
 #NlaStrip.use_auto_blend -> use_auto_blend:   boolean  "Number of frames for Blending In/Out is automatically determined from overlapping strips"
- + * NlaStrip.reversed -> use_reverse:   boolean  "NLA Strip is played back in reverse order (only when timing is automatically determined)"
+#NlaStrip.use_reverse -> use_reverse:   boolean  "NLA Strip is played back in reverse order (only when timing is automatically determined)"
 #+ * NlaTrack.active -> active:   boolean,  "(read-only)    NLA Track is active"
 #NlaTrack.is_solo -> is_solo:   boolean,  "(read-only)    NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled)"
 #+ * NlaTrack.lock -> lock:   boolean  "NLA Track is locked"
 #+ * Node|CompositorNode.type -> type:   enum,  "(read-only)"
 #+ * Node|CompositorNode|CompositorNodeAlphaOver.premul -> premul:   float  "Mix Factor"
 #Node|CompositorNode|CompositorNodeAlphaOver.use_premultiply -> use_premultiply:   boolean  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeZcombine.use_alpha -> use_alpha:   boolean  "NO DESCRIPTION"
 #+ * 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.filter_type -> filter_type:   enum  "NO DESCRIPTION"
 #Node|CompositorNode|CompositorNodeBlur.size_x -> size_x:   int  "NO DESCRIPTION"
 #Node|CompositorNode|CompositorNodeBlur.size_y -> size_y:   int  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeBlur.bokeh -> use_bokeh:   boolean  "Uses circular filter (slower)"
- + * Node|CompositorNode|CompositorNodeBlur.gamma -> use_gamma_correction:   boolean  "Applies filter on gamma corrected values"
- + * Node|CompositorNode|CompositorNodeBlur.relative -> use_relative:   boolean  "Use relative (percent) values to define blur radius"
+#Node|CompositorNode|CompositorNodeBlur.use_bokeh -> use_bokeh:   boolean  "Uses circular filter (slower)"
+#Node|CompositorNode|CompositorNodeBlur.use_gamma_correction -> use_gamma_correction:   boolean  "Applies filter on gamma corrected values"
+#Node|CompositorNode|CompositorNodeBlur.use_relative -> use_relative:   boolean  "Use relative (percent) values to define blur radius"
 #+ * Node|CompositorNode|CompositorNodeChannelMatte.color_space -> color_space:   enum  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeChannelMatte.limit_channel -> limit_channel:   enum  "Limit by this channels value"
- + * Node|CompositorNode|CompositorNodeChannelMatte.high -> limit_max:   float  "Values higher than this setting are 100% opaque"
+#Node|CompositorNode|CompositorNodeChannelMatte.limit_max -> limit_max:   float  "Values higher than this setting are 100% opaque"
 #Node|CompositorNode|CompositorNodeChannelMatte.limit_method -> limit_method:   enum  "Algorithm to use to limit channel"
- + * Node|CompositorNode|CompositorNodeChannelMatte.low -> limit_min:   float  "Values lower than this setting are 100% keyed"
- + * Node|CompositorNode|CompositorNodeChannelMatte.channel -> matte_channel:   enum  "Channel used to determine matte"
+#Node|CompositorNode|CompositorNodeChannelMatte.limit_min -> limit_min:   float  "Values lower than this setting are 100% keyed"
+#Node|CompositorNode|CompositorNodeChannelMatte.matte_channel -> matte_channel:   enum  "Channel used to determine matte"
 #+ * 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|CompositorNodeChromaMatte.cutoff -> threshold:   float  "Tolerance below which colors will be considered as exact matches"
+#Node|CompositorNode|CompositorNodeChromaMatte.threshold -> threshold:   float  "Tolerance below which colors will be considered as exact matches"
 #Node|CompositorNode|CompositorNodeChromaMatte.tolerance -> tolerance:   float  "Tolerance for a color to be considered a keying color"
 #Node|CompositorNode|CompositorNodeColorBalance.correction_method -> correction_method:   enum  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeColorBalance.gain -> gain:   float[3]  "Correction for Highlights"
 #+ * Node|CompositorNode|CompositorNodeColorBalance.offset -> offset:   float[3]  "Correction for Shadows"
 #+ * Node|CompositorNode|CompositorNodeColorBalance.power -> power:   float[3]  "Correction for Midtones"
 #+ * Node|CompositorNode|CompositorNodeColorBalance.slope -> slope:   float[3]  "Correction for Highlights"
- + * Node|CompositorNode|CompositorNodeColorMatte.h -> color_hue:   float  "Hue tolerance for colors to be considered a keying color"
- + * Node|CompositorNode|CompositorNodeColorMatte.s -> color_saturation:   float  "Saturation Tolerance for the color"
- + * Node|CompositorNode|CompositorNodeColorMatte.v -> color_value:   float  "Value Tolerance for the color"
+#Node|CompositorNode|CompositorNodeColorMatte.color_hue -> color_hue:   float  "Hue tolerance for colors to be considered a keying color"
+#Node|CompositorNode|CompositorNodeColorMatte.color_saturation -> color_saturation:   float  "Saturation Tolerance for the color"
+#Node|CompositorNode|CompositorNodeColorMatte.color_value -> color_value:   float  "Value Tolerance for the color"
 #+ * Node|CompositorNode|CompositorNodeColorSpill.channel -> channel:   enum  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeColorSpill.limit_channel -> limit_channel:   enum  "NO DESCRIPTION"
 #Node|CompositorNode|CompositorNodeColorSpill.limit_method -> limit_method:   enum  "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.use_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.blur_max -> blur_max:   float  "blur limit, maximum CoC radius, 0=no limit"
 #+ * 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_gamma_correction -> use_gamma_correction:   boolean  "Enable gamma correction before and after main process"
- + * Node|CompositorNode|CompositorNodeDefocus.preview -> use_preview:   boolean  "Enable sampling mode, useful for preview when using low samplecounts"
+#Node|CompositorNode|CompositorNodeDefocus.use_preview -> use_preview:   boolean  "Enable sampling mode, useful for preview when using low samplecounts"
 #+ * 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|CompositorNodeGlare.threshold -> threshold:   float  "The glare filter will only be applied to pixels brighter than this value"
 #Node|CompositorNode|CompositorNodeGlare.use_rotate_45 -> use_rotate_45:   boolean  "Simple star filter: add 45 degree rotation offset"
 #+ * Node|CompositorNode|CompositorNodeHueCorrect.mapping -> mapping:   pointer,  "(read-only)"
- + * Node|CompositorNode|CompositorNodeHueSat.hue -> color_hue:   float  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeHueSat.sat -> color_saturation:   float  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeHueSat.val -> color_value:   float  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeHueSat.color_hue -> color_hue:   float  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeHueSat.color_saturation -> color_saturation:   float  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeHueSat.color_value -> color_value:   float  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeIDMask.index -> index:   int  "Pass index number to convert to alpha"
- + * Node|CompositorNode|CompositorNodeImage.frames -> frame_duration:   int  "Number of images used in animation"
- + * Node|CompositorNode|CompositorNodeImage.offset -> frame_offset:   int  "Offsets the number of the frame to use in the animation"
- + * Node|CompositorNode|CompositorNodeImage.start -> frame_start:   int  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeImage.frame_duration -> frame_duration:   int  "Number of images used in animation"
+#Node|CompositorNode|CompositorNodeImage.frame_offset -> frame_offset:   int  "Offsets the number of the frame to use in the animation"
+#Node|CompositorNode|CompositorNodeImage.frame_start -> frame_start:   int  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeImage.image -> image:   pointer  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeImage.layer -> layer:   enum  "NO DESCRIPTION"
 #Node|CompositorNode|CompositorNodeImage.use_auto_refresh -> use_auto_refresh:   boolean  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeImage.cyclic -> use_cyclic:   boolean  "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|CompositorNodeImage.use_cyclic -> use_cyclic:   boolean  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeInvert.invert_alpha -> invert_alpha:   boolean  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeInvert.invert_rgb -> invert_rgb:   boolean  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeLensdist.use_fit -> use_fit:   boolean  "For positive distortion factor only: scale image such that black areas are not visible"
+#Node|CompositorNode|CompositorNodeLensdist.use_jitter -> use_jitter:   boolean  "Enable/disable jittering; faster, but also noisier"
 #Node|CompositorNode|CompositorNodeLensdist.use_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|CompositorNodeLumaMatte.limit_max -> limit_max:   float  "Values higher than this setting are 100% opaque"
+#Node|CompositorNode|CompositorNodeLumaMatte.limit_min -> limit_min:   float  "Values lower than this setting are 100% keyed"
 #+ * Node|CompositorNode|CompositorNodeMapUV.alpha -> alpha:   int  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeMapValue.max -> max:   float[1]  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeMapValue.min -> min:   float[1]  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeMapValue.use_min -> use_min:   boolean  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeMath.operation -> operation:   enum  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeMixRGB.blend_type -> blend_type:   enum  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeMixRGB.alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
+#Node|CompositorNode|CompositorNodeMixRGB.use_alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
 #+ * Node|CompositorNode|CompositorNodeOutputFile.exr_codec -> exr_codec:   enum  "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|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_type:   enum  "Method to use to filter rotation"
+#Node|CompositorNode|CompositorNodeRotate.filter_type -> filter_type:   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 -> frame_end:   int  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeTime.start -> frame_start:   int  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeTime.frame_end -> frame_end:   int  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeTime.frame_start -> frame_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.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 -> type:   enum  "NO DESCRIPTION"
+#+ * Node|CompositorNode|CompositorNodeTonemap.tonemap_type -> tonemap_type:   enum  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeValToRGB.color_ramp -> color_ramp:   pointer,  "(read-only)"
 #+ * Node|CompositorNode|CompositorNodeVecBlur.factor -> factor:   float  "Scaling factor for motion vectors; actually shutter speed in frames"
 #+ * Node|CompositorNode|CompositorNodeVecBlur.samples -> samples:   int  "NO DESCRIPTION"
 #Node|CompositorNode|CompositorNodeVecBlur.speed_max -> speed_max:   int  "Maximum speed, or zero for none"
 #Node|CompositorNode|CompositorNodeVecBlur.speed_min -> speed_min:   int  "Minimum speed for a pixel to be blurred; used to separate background from foreground"
- + * Node|CompositorNode|CompositorNodeVecBlur.curved -> use_curved:   boolean  "Interpolate between frames in a bezier curve, rather than linearly"
+#Node|CompositorNode|CompositorNodeVecBlur.use_curved -> use_curved:   boolean  "Interpolate between frames in a bezier curve, rather than linearly"
 #+ * Node|NodeGroup.nodetree -> nodetree:   pointer  "NO DESCRIPTION"
 #+ * Node|ShaderNode.type -> type:   enum,  "(read-only)"
 #+ * Node|ShaderNode|ShaderNodeExtendedMaterial.invert_normal -> invert_normal:   boolean  "Material Node uses inverted normal"
 #+ * Node|ShaderNode|ShaderNodeExtendedMaterial.material -> material:   pointer  "NO DESCRIPTION"
- + * Node|ShaderNode|ShaderNodeExtendedMaterial.diffuse -> use_diffuse:   boolean  "Material Node outputs Diffuse"
- + * Node|ShaderNode|ShaderNodeExtendedMaterial.specular -> use_specular:   boolean  "Material Node outputs Specular"
+#Node|ShaderNode|ShaderNodeExtendedMaterial.use_diffuse -> use_diffuse:   boolean  "Material Node outputs Diffuse"
+#Node|ShaderNode|ShaderNodeExtendedMaterial.use_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.location -> location:   float[3]  "Location offset for the input coordinate"
 #Node|ShaderNode|ShaderNodeMapping.use_min -> use_min:   boolean  "Clamp the output coordinate to a minimum value"
 #+ * Node|ShaderNode|ShaderNodeMaterial.invert_normal -> invert_normal:   boolean  "Material Node uses inverted normal"
 #+ * Node|ShaderNode|ShaderNodeMaterial.material -> material:   pointer  "NO DESCRIPTION"
- + * Node|ShaderNode|ShaderNodeMaterial.diffuse -> use_diffuse:   boolean  "Material Node outputs Diffuse"
- + * Node|ShaderNode|ShaderNodeMaterial.specular -> use_specular:   boolean  "Material Node outputs Specular"
+#Node|ShaderNode|ShaderNodeMaterial.use_diffuse -> use_diffuse:   boolean  "Material Node outputs Diffuse"
+#Node|ShaderNode|ShaderNodeMaterial.use_specular -> use_specular:   boolean  "Material Node outputs Specular"
 #+ * Node|ShaderNode|ShaderNodeMath.operation -> operation:   enum  "NO DESCRIPTION"
 #+ * Node|ShaderNode|ShaderNodeMixRGB.blend_type -> blend_type:   enum  "NO DESCRIPTION"
- + * Node|ShaderNode|ShaderNodeMixRGB.alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
+#Node|ShaderNode|ShaderNodeMixRGB.use_alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
 #+ * 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|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 -> frame_end:   int  "NO DESCRIPTION"
- + * Node|TextureNode|TextureNodeCurveTime.start -> frame_start:   int  "NO DESCRIPTION"
+#Node|TextureNode|TextureNodeCurveTime.frame_end -> frame_end:   int  "NO DESCRIPTION"
+#Node|TextureNode|TextureNodeCurveTime.frame_start -> frame_start:   int  "NO DESCRIPTION"
 #+ * Node|TextureNode|TextureNodeImage.image -> image:   pointer  "NO DESCRIPTION"
 #+ * Node|TextureNode|TextureNodeMath.operation -> operation:   enum  "NO DESCRIPTION"
 #+ * Node|TextureNode|TextureNodeMixRGB.blend_type -> blend_type:   enum  "NO DESCRIPTION"
- + * Node|TextureNode|TextureNodeMixRGB.alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
- + * Node|TextureNode|TextureNodeOutput.output_name -> filepath:   string  "NO DESCRIPTION"
+#Node|TextureNode|TextureNodeMixRGB.use_alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
+#Node|TextureNode|TextureNodeOutput.filepath -> filepath:   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)"
 #Paint|Sculpt.use_symmetry_z -> use_symmetry_z:   boolean  "Mirror brush across the Z axis"
 #Paint|Sculpt.use_threaded -> use_threaded:   boolean  "Take advantage of multiple CPU cores to improve sculpting performance"
 #Paint|VertexPaint.use_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.use_normal -> use_normal:   boolean  "Applies the vertex normal before painting"
 #Paint|VertexPaint.use_spray -> use_spray:   boolean  "Keep applying paint effect while holding mouse"
 #+ * Panel.bl_context -> bl_context:   string  "The context in which the panel belongs to. (TODO: explain the possible combinations bl_context/bl_region_type/bl_space_type)"
 #+ * Panel.bl_idname -> bl_idname:   string  "If this is set, the panel gets a custom ID, otherwise it takes the name of the class used to define the panel. For example, if the class name is OBJECT_PT_hello, and bl_idname is not set by the script, then bl_idname = OBJECT_PT_hello"
 #Particle.is_hair -> is_hair:   collection,  "(read-only)"
 #+ * Particle.is_visible -> is_visible:   boolean,  "(read-only)"
 #+ * Particle.keys -> keys:   collection,  "(read-only)"
- + * Particle.lifetime -> life_time:   float  "NO DESCRIPTION"
+#+ * Particle.lifetime -> lifetime:   float  "NO DESCRIPTION"
 #+ * Particle.location -> location:   float[3]  "NO DESCRIPTION"
 #+ * Particle.prev_angular_velocity -> prev_angular_velocity:   float[3]  "NO DESCRIPTION"
 #+ * Particle.prev_location -> prev_location:   float[3]  "NO DESCRIPTION"
 #+ * PointDensity.turbulence_strength -> turbulence_strength:   float  "NO DESCRIPTION"
 #PointDensity.use_turbulence -> use_turbulence:   boolean  "Add directed noise to the density at render-time"
 #PointDensity.vertex_cache_space -> vertex_cache_space:   enum  "Co-ordinate system to cache vertices in"
-#+ * Pose.active_bone_group -> active_bone_group:   pointer  "Active bone group for this pose"
 #+ * Pose.active_bone_group_index -> active_bone_group_index:   int  "Active index in bone groups array"
 #+ * Pose.animation_visualisation -> animation_visualisation:   pointer,  "(read-only)    Animation data for this datablock"
 #+ * Pose.bone_groups -> bone_groups:   collection,  "(read-only)    Groups of the bones"
 #+ * RenderSettings.edge_color -> edge_color:   float[3]  "NO DESCRIPTION"
 #+ * RenderSettings.edge_threshold -> edge_threshold:   int  "Threshold for drawing outlines on geometry edges"
 #+ * RenderSettings.engine -> engine:   enum  "Engine to use for rendering"
-#RenderSettings.exr_codec -> exr_codec:   enum  "Codec settings for OpenEXR"
-#RenderSettings.exr_preview -> exr_preview:   boolean  "When rendering animations, save JPG preview images in same directory"
-#RenderSettings.exr_zbuf -> exr_zbuf:   boolean  "Save the z-depth per pixel (32 bit unsigned int zbuffer)"
 #+ * RenderSettings.field_order -> field_order:   enum  "Order of video fields. Select which lines get rendered first, to create smooth motion for TV output"
 #+ * RenderSettings.file_extension -> file_extension:   string,  "(read-only)    The file extension used for saving renders"
 #+ * RenderSettings.file_format -> file_format:   enum  "File format to save the rendered images as"
 #+ * RenderSettings.fps_base -> fps_base:   float  "Framerate base"
 #RenderSettings.has_multiple_engines -> has_multiple_engines:   boolean,  "(read-only)    More than one rendering engine is available"
 #+ * RenderSettings.is_movie_format -> is_movie_format:   boolean,  "(read-only)    When true the format is a movie"
-#RenderSettings.jpeg2k_depth -> jpeg2k_depth:   enum  "Bit depth per channel"
-#RenderSettings.jpeg2k_preset -> jpeg2k_preset:   enum  "Use a DCI Standard preset for saving jpeg2000"
-#RenderSettings.jpeg2k_ycc -> jpeg2k_ycc:   boolean  "Save luminance-chrominance-chrominance channels instead of RGB colors"
 #+ * RenderSettings.layers -> layers:   collection,  "(read-only)"
 #+ * RenderSettings.motion_blur_samples -> motion_blur_samples:   int  "Number of scene samples to take with motion blur"
 #+ * RenderSettings.motion_blur_shutter -> motion_blur_shutter:   float  "Time taken in frames between shutter open and close"
 #RenderSettings.use_crop_to_border -> use_crop_to_border:   boolean  "Crop the rendered frame to the defined border size"
 #RenderSettings.use_edge_enhance -> use_edge_enhance:   boolean  "Create a toon outline around the edges of geometry"
 #+ * RenderSettings.use_envmaps -> use_envmaps:   boolean  "Calculate environment maps while rendering"
-#RenderSettings.use_exr_half -> use_exr_half:   boolean  "Use 16 bit floats instead of 32 bit floats per channel"
 #RenderSettings.use_fields -> use_fields:   boolean  "Render image to two fields per frame, for interlaced TV output"
 #RenderSettings.use_fields_still -> use_fields_still:   boolean  "Disable the time difference between fields"
 #+ * RenderSettings.use_file_extension -> use_file_extension:   boolean  "Add the file format extensions to the rendered file name (eg: filename + .jpg)"
 #SequenceColorBalance.invert_gamma -> invert_gamma:   boolean  "NO DESCRIPTION"
 #SequenceColorBalance.invert_lift -> invert_lift:   boolean  "NO DESCRIPTION"
 #+ * SequenceColorBalance.lift -> lift:   float[3]  "Color balance lift (shadows)"
- + * SequenceCrop.right -> max_x:   int  "NO DESCRIPTION"
- + * SequenceCrop.top -> max_y:   int  "NO DESCRIPTION"
- + * SequenceCrop.bottom -> min_x:   int  "NO DESCRIPTION"
- + * SequenceCrop.left -> min_y:   int  "NO DESCRIPTION"
+#SequenceCrop.max_x -> max_x:   int  "NO DESCRIPTION"
+#SequenceCrop.max_y -> max_y:   int  "NO DESCRIPTION"
+#SequenceCrop.min_x -> min_x:   int  "NO DESCRIPTION"
+#SequenceCrop.min_y -> min_y:   int  "NO DESCRIPTION"
 #+ * SequenceEditor.active_strip -> active_strip:   pointer  "NO DESCRIPTION"
 #+ * SequenceEditor.meta_stack -> meta_stack:   collection,  "(read-only)    Meta strip stack, last is currently edited meta strip"
 #+ * SequenceEditor.overlay_frame -> overlay_frame:   int  "Sequencers active strip"
 #SmokeDomainSettings.collision_extents -> collision_extents:   enum  "Selects which domain border will be treated as collision object."
 #SmokeDomainSettings.collision_group -> collision_group:   pointer  "Limit collisions to this group"
 #+ * SmokeDomainSettings.dissolve_speed -> dissolve_speed:   int  "Dissolve Speed"
-#+ * SmokeDomainSettings.eff_group -> eff_group:   pointer  "Limit effectors to this group"
+#SmokeDomainSettings.effector_group -> effector_group:   pointer  "Limit effectors to this group"
 #+ * SmokeDomainSettings.effector_weights -> effector_weights:   pointer,  "(read-only)"
 #+ * SmokeDomainSettings.fluid_group -> fluid_group:   pointer  "Limit fluid objects to this group"
 #+ * SmokeDomainSettings.noise_type -> noise_type:   enum  "Noise method which is used for creating the high resolution"
 #SoftBodySettings.bend -> bend:   float  "Bending Stiffness"
 #+ * SoftBodySettings.choke -> choke:   int  "Viscosity inside collision target"
 #+ * SoftBodySettings.collision_type -> collision_type:   enum  "Choose Collision Type"
- + * SoftBodySettings.damp -> damping:   float  "Edge spring friction"
+#SoftBodySettings.damping -> damping:   float  "Edge spring friction"
 #+ * SoftBodySettings.effector_weights -> effector_weights:   pointer,  "(read-only)"
 #SoftBodySettings.error_threshold -> error_threshold:   float  "The Runge-Kutta ODE solver error limit, low value gives more precision, high values speed"
 #+ * SoftBodySettings.friction -> friction:   float  "General media friction for point movements"
 #+ * TextureSlot.blend_type -> blend_type:   enum  "NO DESCRIPTION"
 #+ * TextureSlot.color -> color:   float[3]  "The default color for textures that dont return RGB"
 #+ * TextureSlot.default_value -> default_value:   float  "Value to use for Ref, Spec, Amb, Emit, Alpha, RayMir, TransLu and Hard"
- + * TextureSlot.negate -> invert:   boolean  "Inverts the values of the texture to reverse its effect"
+#TextureSlot.invert -> invert:   boolean  "Inverts the values of the texture to reverse its effect"
 #+ * TextureSlot.name -> name:   string,  "(read-only)    Texture slot name"
 #+ * TextureSlot.offset -> offset:   float[3]  "Fine tunes texture mapping X, Y and Z locations"
 #+ * TextureSlot.output_node -> output_node:   enum  "Which output node to use, for node-based textures"
- + * TextureSlot.size -> scale:   float[3]  "Sets scaling for the textures X, Y and Z sizes"
+#TextureSlot.scale -> scale:   float[3]  "Sets scaling for the textures X, Y and Z sizes"
 #+ * TextureSlot.texture -> texture:   pointer  "Texture datablock used by this texture slot"
 #TextureSlot.use_rgb_to_intensity -> use_rgb_to_intensity:   boolean  "Converts texture RGB values to intensity (gray) values"
 #TextureSlot.use_stencil -> use_stencil:   boolean  "Use this texture as a blending value on the next texture"
  + * UILayout.active -> show_active:   boolean  "NO DESCRIPTION"
  + * UILayout.enabled -> show_enabled:   boolean  "When false, this (sub)layout is greyed out."
 #+ * UVProjector.object -> object:   pointer  "Object to use as projector transform"
+#UVTextures.active -> active:   pointer  "Active UV texture"
 #+ * UnitSettings.rotation_units -> rotation_units:   enum  "Unit to use for displaying/editing rotation values"
 #+ * UnitSettings.scale_length -> scale_length:   float  "Scale to use when converting between blender units and dimensions"
 #+ * UnitSettings.system -> system:   enum  "The unit system to use for button display"
 #+ * ValueNodeSocket.name -> name:   string,  "(read-only)    Socket name"
 #+ * VectorNodeSocket.default_value -> default_value:   float[3]  "Default value of the socket when no link is attached"
 #+ * VectorNodeSocket.name -> name:   string,  "(read-only)    Socket name"
+#VertexColors.active -> active:   pointer  "Active vertex color layer"
 #+ * VertexGroup.index -> index:   int,  "(read-only)    Index number of the vertex group"
 #+ * VertexGroup.name -> name:   string  "Vertex group name"
 #+ * VertexGroupElement.group -> group:   int,  "(read-only)"
 #+ * VoxelData.resolution -> resolution:   int[3]  "Resolution of the voxel grid"
 #+ * VoxelData.smoke_data_type -> smoke_data_type:   enum  "Simulation value to be used as a texture"
 #VoxelData.still_frame -> still_frame:   int  "The frame number to always use"
- + * VoxelData.still -> use_still_frame:   boolean  "Always render a still frame from the voxel data sequence"
+#VoxelData.use_still_frame -> use_still_frame:   boolean  "Always render a still frame from the voxel data sequence"
 #+ * Window.screen -> screen:   pointer  "Active screen showing in the window"
 #+ * WorldLighting.adapt_to_speed -> adapt_to_speed:   float  "Use the speed vector pass to reduce AO samples in fast moving pixels. Higher values result in more aggressive sample reduction. Requires Vec pass enabled (for Raytrace Adaptive QMC)"
 #WorldLighting.ao_blend_type -> ao_blend_type:   enum  "Defines how AO mixes with material shading"
 #+ * WorldLighting.use_ambient_occlusion -> use_ambient_occlusion:   boolean  "Use Ambient Occlusion to add shadowing based on distance between objects"
 #WorldLighting.use_cache -> use_cache:   boolean  "Cache AO results in pixels and interpolate over neighbouring pixels for speedup (for Approximate)"
 #WorldLighting.use_environment_light -> use_environment_light:   boolean  "Add light coming from the environment"
- + * WorldLighting.falloff -> use_falloff:   boolean  "NO DESCRIPTION"
+#WorldLighting.use_falloff -> use_falloff:   boolean  "NO DESCRIPTION"
 #WorldLighting.use_indirect_light -> use_indirect_light:   boolean  "Add indirect light bouncing of surrounding objects"
 #+ * WorldMistSettings.depth -> depth:   float  "The distance over which the mist effect fades in"
 #+ * WorldMistSettings.falloff -> falloff:   enum  "Type of transition used to fade mist"