rna refactor...

[blender-staging.git] / source / blender / makesrna / rna_cleanup / rna_properties.txt

NOTE * CLASS.FROM -> TO:   TYPE  DESCRIPTION
Action.fcurves -> fcurves:   collection,  '(read-only)    The individual F-Curves that make up the Action'
Action.groups -> groups:   collection,  '(read-only)    Convenient groupings of F-Curves'
Action.pose_markers -> pose_markers:   collection,  '(read-only)    Markers specific to this Action, for labeling poses'
ActionActuator.action -> action:   pointer  'NO DESCRIPTION'
ActionActuator.blendin -> blendin:   int  'Number of frames of motion blending'
ActionActuator.continue_last_frame -> use_continue_last_frame:   boolean  'Restore last frame when switching on/off, otherwise play from the start each time'
ActionActuator.frame_end -> frame_end:   int  'NO DESCRIPTION'
ActionActuator.frame_property -> frame_property:   string  "Assign the action's current frame number to this property"
ActionActuator.frame_start -> frame_start:   int  'NO DESCRIPTION'
ActionActuator.mode -> mode:   enum  'Action playback type'
ActionActuator.priority -> priority:   int  'Execution priority - lower numbers will override actions with higher numbers. With 2 or more actions at once, the overriding channels must be lower in the stack'
ActionActuator.property -> property:   string  'Use this property to define the Action position'
ActionConstraint.action -> action:   pointer  'NO DESCRIPTION'
ActionConstraint.frame_end -> frame_end:   int  'Last frame of the Action to use'
ActionConstraint.frame_start -> frame_start:   int  'First frame of the Action to use'
ActionConstraint.maximum -> max:   float  'Maximum value for target channel range'
ActionConstraint.minimum -> min:   float  'Minimum value for target channel range'
ActionConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
ActionConstraint.target -> target:   pointer  'Target Object'
ActionConstraint.transform_channel -> transform_channel:   enum  'Transformation channel from the target that is used to key the Action'
ActionGroup.channels -> channels:   collection,  '(read-only)    F-Curves in this group'
ActionGroup.custom_color -> custom_color:   int  'Index of custom color set'
ActionGroup.expanded -> show_expanded:   boolean  'Action Group is expanded'
ActionGroup.lock -> lock:   boolean  'Action Group is locked'
ActionGroup.name -> name:   string  'NO DESCRIPTION'
ActionGroup.select -> select:   boolean  'Action Group is selected'
Actuator.expanded -> show_expanded:   boolean  'Set actuator expanded in the user interface'
Actuator.name -> name:   string  'NO DESCRIPTION'
Actuator.pinned -> pinned:   boolean  'Display when not linked to a visible states controller'
Actuator.type -> type:   enum  'NO DESCRIPTION'
ActuatorSensor.actuator -> actuator:   string  'Actuator name, actuator active state modifications will be detected'
Addon.module -> module:   string  'Module name'
AnimData.action -> action:   pointer  'Active Action for this datablock'
AnimData.action_blending -> action_blend_type:   enum  "Method used for combining Active Action's result with result of NLA stack"
AnimData.action_extrapolation -> action_extrapolation:   enum  "Action to take for gaps past the Active Action's range (when evaluating with NLA)"
AnimData.action_influence -> action_influence:   float  'Amount the Active Action contributes to the result of the NLA stack'
AnimData.drivers -> drivers:   collection,  '(read-only)    The Drivers/Expressions for this datablock'
AnimData.nla_enabled -> use_nla:   boolean  'NLA stack is evaluated when evaluating this block'
AnimData.nla_tracks -> nla_tracks:   collection,  '(read-only)    NLA Tracks (i.e. Animation Layers)'
AnimViz.motion_paths -> motion_paths:   pointer,  '(read-only)    Motion Path settings for visualisation'
AnimViz.onion_skinning -> onion_skin_frames:   pointer,  '(read-only)    Onion Skinning (ghosting) settings for visualisation'
AnimVizMotionPaths.after_current -> after_current:   int  "Number of frames to show after the current frame (only for 'Around Current Frame' Onion-skinning method)"
AnimVizMotionPaths.bake_location -> bake_location:   enum  'When calculating Bone Paths, use Head or Tips'
AnimVizMotionPaths.before_current -> before_current:   int  "Number of frames to show before the current frame (only for 'Around Current Frame' Onion-skinning method)"
AnimVizMotionPaths.frame_end -> frame_end:   int  "End frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method)"
AnimVizMotionPaths.frame_start -> frame_start:   int  "Starting frame of range of paths to display/calculate (not for 'Around Current Frame' Onion-skinning method)"
AnimVizMotionPaths.frame_step -> frame_step:   int  "Number of frames between paths shown (not for 'On Keyframes' Onion-skinning method)"
AnimVizMotionPaths.highlight_keyframes -> show_keyframe_highlight:   boolean  'Emphasize position of keyframes on Motion Paths'
AnimVizMotionPaths.search_all_action_keyframes -> show_keyframe_action_all:   boolean  'For bone motion paths, search whole Action for keyframes instead of in group with matching name only (is slower)'
AnimVizMotionPaths.show_frame_numbers -> show_frame_numbers:   boolean  'Show frame numbers on Motion Paths'
AnimVizMotionPaths.show_keyframe_numbers -> show_keyframe_numbers:   boolean  'Show frame numbers of Keyframes on Motion Paths'
AnimVizMotionPaths.type -> type:   enum  'Type of range to show for Motion Paths'
AnimVizOnionSkinning.after_current -> after_current:   int  "Number of frames to show after the current frame (only for 'Around Current Frame' Onion-skinning method)"
AnimVizOnionSkinning.before_current -> before_current:   int  "Number of frames to show before the current frame (only for 'Around Current Frame' Onion-skinning method)"
AnimVizOnionSkinning.frame_end -> frame_end:   int  "End frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method)"
AnimVizOnionSkinning.frame_start -> frame_start:   int  "Starting frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method)"
AnimVizOnionSkinning.frame_step -> frame_step:   int  "Number of frames between ghosts shown (not for 'On Keyframes' Onion-skinning method)"
AnimVizOnionSkinning.only_selected -> show_only_selected:   boolean  'For Pose-Mode drawing, only draw ghosts for selected bones'
AnimVizOnionSkinning.type -> type:   enum  'Method used for determining what ghosts get drawn'
Area.active_space -> active_space:   pointer,  '(read-only)    Space currently being displayed in this area'
Area.regions -> regions:   collection,  '(read-only)    Regions this area is subdivided in'
Area.show_menus -> show_menus:   boolean  'Show menus in the header'
Area.spaces -> spaces:   collection,  '(read-only)    Spaces contained in this area, the first space is active'
Area.type -> type:   enum  'Space type'
AreaLamp.dither -> use_dither:   boolean  'Use 2x2 dithering for sampling  (Constant Jittered sampling)'
AreaLamp.gamma -> gamma:   float  'Light gamma correction value'
AreaLamp.jitter -> use_jitter:   boolean  'Use noise for sampling  (Constant Jittered sampling)'
AreaLamp.only_shadow -> use_only_shadow:   boolean  'Causes light to cast shadows only without illuminating objects'
AreaLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:   float  'Threshold for Adaptive Sampling (Raytraced shadows)'
AreaLamp.shadow_color -> shadow_color:   float  'Color of shadows cast by the lamp'
AreaLamp.shadow_layer -> use_shadow_layer:   boolean  'Causes only objects on the same layer to cast shadows'
AreaLamp.shadow_method -> shadow_method:   enum  'Method to compute lamp shadow with'
AreaLamp.shadow_ray_samples_x -> shadow_ray_samples_x:   int  'Amount of samples taken extra (samples x samples)'
AreaLamp.shadow_ray_samples_y -> shadow_ray_samples_y:   int  'Amount of samples taken extra (samples x samples)'
AreaLamp.shadow_ray_sampling_method -> shadow_ray_sample_method:   enum  'Method for generating shadow samples: Adaptive QMC is fastest, Constant QMC is less noisy but slower'
AreaLamp.shadow_soft_size -> shadow_soft_size:   float  'Light size for ray shadow sampling (Raytraced shadows)'
AreaLamp.shape -> shape:   enum  'Shape of the area lamp'
AreaLamp.size -> size:   float  'Size of the area of the area Lamp, X direction size for Rectangle shapes'
AreaLamp.size_y -> size_y:   float  'Size of the area of the area Lamp in the Y direction for Rectangle shapes'
AreaLamp.umbra -> use_umbra:   boolean  'Emphasize parts that are fully shadowed (Constant Jittered sampling)'
Armature.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
Armature.auto_ik -> use_auto_ik:   boolean  'Add temporaral IK constraints while grabbing bones in Pose Mode'
Armature.bones -> bones:   collection,  '(read-only)'
Armature.deform_envelope -> use_deform_envelopes:   boolean  'Enable Bone Envelopes when defining deform'
Armature.deform_quaternion -> use_deform_preserve_volume:   boolean  'Deform rotation interpolation with quaternions'
Armature.deform_vertexgroups -> use_deform_vertex_groups:   boolean  'Enable Vertex Groups when defining deform'
Armature.delay_deform -> use_deform_delay:   boolean  "Don't deform children when manipulating bones in Pose Mode"
Armature.draw_axes -> show_axes:   boolean  'Draw bone axes'
Armature.draw_custom_bone_shapes -> show_bone_custom_shapes:   boolean  'Draw bones with their custom shapes'
Armature.draw_group_colors -> show_group_colors:   boolean  'Draw bone group colors'
Armature.draw_names -> show_names:   boolean  'Draw bone names'
Armature.drawtype -> drawtype:   enum  'NO DESCRIPTION'
Armature.edit_bones -> edit_bones:   collection,  '(read-only)'
Armature.ghost_frame_end -> ghost_frame_end:   int  "End frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method)"
Armature.ghost_frame_start -> ghost_frame_start:   int  "Starting frame of range of Ghosts to display (not for 'Around Current Frame' Onion-skinning method)"
Armature.ghost_only_selected -> show_only_ghost_selected:   boolean  'NO DESCRIPTION'
Armature.ghost_size -> ghost_size:   int  "Frame step for Ghosts (not for 'On Keyframes' Onion-skinning method)"
Armature.ghost_step -> ghost_step:   int  "Number of frame steps on either side of current frame to show as ghosts (only for 'Around Current Frame' Onion-skinning method)"
Armature.ghost_type -> ghost_type:   enum  'Method of Onion-skinning for active Action'
Armature.layer -> layers:   boolean  'Armature layer visibility'
Armature.layer_protection -> layers_protected:   boolean  'Protected layers in Proxy Instances are restored to Proxy settings on file reload and undo'
Armature.pose_position -> pose_position:   enum  'Show armature in binding pose or final posed state'
Armature.x_axis_mirror -> use_mirror_x:   boolean  'Apply changes to matching bone on opposite side of X-Axis'
ArmatureActuator.bone -> bone:   string  'Bone on which the constraint is defined'
ArmatureActuator.constraint -> constraint:   string  'Name of the constraint you want to control'
ArmatureActuator.mode -> mode:   enum  'NO DESCRIPTION'
ArmatureActuator.secondary_target -> secondary_target:   pointer  'Set weight of this constraint'
ArmatureActuator.target -> target:   pointer  'Set this object as the target of the constraint'
ArmatureActuator.weight -> weight:   float  'Set weight of this constraint'
ArmatureBones.active -> active:   pointer  'Armatures active bone'
ArmatureEditBones.active -> active:   pointer  'Armatures active edit bone'
ArmatureModifier.invert -> invert_vertex_group:   boolean  'Invert vertex group influence'
ArmatureModifier.multi_modifier -> use_multi_modifier:   boolean  'Use same input as previous modifier, and mix results using overall vgroup'
ArmatureModifier.object -> object:   pointer  'Armature object to deform with'
ArmatureModifier.quaternion -> use_deform_preserve_volume:   boolean  'Deform rotation interpolation with quaternions'
ArmatureModifier.use_bone_envelopes -> use_bone_envelopes:   boolean  'NO DESCRIPTION'
ArmatureModifier.use_vertex_groups -> use_vertex_groups:   boolean  'NO DESCRIPTION'
ArmatureModifier.vertex_group -> vertex_group:   string  'Vertex group name'
ArmatureSensor.bone -> bone:   string  'Identify the bone to check value from'
ArmatureSensor.constraint -> constraint:   string  'Identify the bone constraint to check value from'
ArmatureSensor.test_type -> test_type:   enum  'Type of value and test'
ArmatureSensor.value -> value:   float  'Specify value to be used in comparison'
ArrayModifier.add_offset_object -> use_object_offset:   boolean  "Add another object's transformation to the total offset"
ArrayModifier.constant_offset -> use_constant_offset:   boolean  'Add a constant offset'
ArrayModifier.constant_offset_displacement -> constant_offset_displacement:   float  'NO DESCRIPTION'
ArrayModifier.count -> count:   int  'Number of duplicates to make'
ArrayModifier.curve -> curve:   pointer  'Curve object to fit array length to'
ArrayModifier.end_cap -> end_cap:   pointer  'Mesh object to use as an end cap'
ArrayModifier.fit_type -> fit_type:   enum  'Array length calculation method'
ArrayModifier.length -> length:   float  'Length to fit array within'
ArrayModifier.merge_adjacent_vertices -> use_merge_adjacent_vertices:   boolean  'Merge vertices in adjacent duplicates'
ArrayModifier.merge_distance -> merge_distance:   float  'Limit below which to merge vertices'
ArrayModifier.merge_end_vertices -> use_merge_end_vertices:   boolean  'Merge vertices in first and last duplicates'
ArrayModifier.offset_object -> offset_object:   pointer  'NO DESCRIPTION'
ArrayModifier.relative_offset -> use_relative_offset:   boolean  "Add an offset relative to the object's bounding box"
ArrayModifier.relative_offset_displacement -> relative_offset_displacement:   float  'NO DESCRIPTION'
ArrayModifier.start_cap -> start_cap:   pointer  'Mesh object to use as a start cap'
BackgroundImage.image -> image:   pointer  'Image displayed and edited in this space'
BackgroundImage.image_user -> image_user:   pointer,  '(read-only)    Parameters defining which layer, pass and frame of the image is displayed'
BackgroundImage.offset_x -> offset_x:   float  'Offsets image horizontally from the world origin'
BackgroundImage.offset_y -> offset_y:   float  'Offsets image vertically from the world origin'
BackgroundImage.show_expanded -> show_expanded:   boolean  'Show the expanded in the user interface'
BackgroundImage.size -> size:   float  'Scaling factor for the background image'
BackgroundImage.transparency -> transparency:   float  'Amount to blend the image against the background color'
BackgroundImage.view_axis -> view_axis:   enum  'The axis to display the image on'
BevelModifier.angle -> angle:   float  'Angle above which to bevel edges'
BevelModifier.edge_weight_method -> edge_weight_method:   enum  'What edge weight to use for weighting a vertex'
BevelModifier.limit_method -> limit_method:   enum  'NO DESCRIPTION'
BevelModifier.only_vertices -> use_only_vertices:   boolean  'Bevel verts/corners, not edges'
BevelModifier.width -> width:   float  'Bevel value/amount'
BezierSplinePoint.co -> co:   float  'Coordinates of the control point'
BezierSplinePoint.handle1 -> handle_left:   float  'Coordinates of the first handle'
BezierSplinePoint.handle1_type -> handle_left_type:   enum  'Handle types'
BezierSplinePoint.handle2 -> handle_right:   float  'Coordinates of the second handle'
BezierSplinePoint.handle2_type -> handle_right_type:   enum  'Handle types'
BezierSplinePoint.hide -> hide:   boolean  'Visibility status'
BezierSplinePoint.radius -> radius:   float,  '(read-only)    Radius for bevelling'
BezierSplinePoint.select_control_point -> select_control_point:   boolean  'Control point selection status'
BezierSplinePoint.select_left_handle -> select_left_handle:   boolean  'Handle 1 selection status'
BezierSplinePoint.select_right_handle -> select_right_handle:   boolean  'Handle 2 selection status'
BezierSplinePoint.tilt -> tilt:   float  'Tilt in 3D View'
BezierSplinePoint.weight -> weight:   float  'Softbody goal weight'
BlendTexture.flip_axis -> flip_axis:   enum  "Flips the texture's X and Y axis"
BlendTexture.progression -> progression:   enum  'Sets the style of the color blending'
BlenderRNA.structs -> structs:   collection,  '(read-only)'
BoidRule.in_air -> use_in_air:   boolean  'Use rule when boid is flying'
BoidRule.name -> name:   string  'Boid rule name'
BoidRule.on_land -> use_on_land:   boolean  'Use rule when boid is on land'
BoidRule.type -> type:   enum,  '(read-only)'
BoidRuleAverageSpeed.level -> level:   float  "How much velocity's z-component is kept constant"
BoidRuleAverageSpeed.speed -> speed:   float  'Percentage of maximum speed'
BoidRuleAverageSpeed.wander -> wander:   float  "How fast velocity's direction is randomized"
BoidRuleAvoid.fear_factor -> fear_factor:   float  'Avoid object if danger from it is above this threshold'
BoidRuleAvoid.object -> object:   pointer  'Object to avoid'
BoidRuleAvoid.predict -> use_predict:   boolean  'Predict target movement'
BoidRuleAvoidCollision.boids -> use_avoid:   boolean  'Avoid collision with other boids'
BoidRuleAvoidCollision.deflectors -> use_avoid_collision:   boolean  'Avoid collision with deflector objects'
BoidRuleAvoidCollision.look_ahead -> look_ahead:   float  'Time to look ahead in seconds'
BoidRuleFight.distance -> distance:   float  'Attack boids at max this distance'
BoidRuleFight.flee_distance -> flee_distance:   float  'Flee to this distance'
BoidRuleFollowLeader.distance -> distance:   float  'Distance behind leader to follow'
BoidRuleFollowLeader.line -> use_line:   boolean  'Follow leader in a line'
BoidRuleFollowLeader.object -> object:   pointer  'Follow this object instead of a boid'
BoidRuleFollowLeader.queue_size -> queue_size:   int  'How many boids in a line'
BoidRuleGoal.object -> object:   pointer  'Goal object'
BoidRuleGoal.predict -> use_predict:   boolean  'Predict target movement'
BoidSettings.accuracy -> accuracy:   float  'Accuracy of attack'
BoidSettings.active_boid_state -> active_boid_state:   pointer,  '(read-only)'
BoidSettings.active_boid_state_index -> active_boid_state_index:   int  'NO DESCRIPTION'
BoidSettings.aggression -> aggression:   float  'Boid will fight this times stronger enemy'
BoidSettings.air_max_acc -> air_acc_max:   float  'Maximum acceleration in air (relative to maximum speed)'
BoidSettings.air_max_ave -> air_ave_max:   float  'Maximum angular velocity in air (relative to 180 degrees)'
BoidSettings.air_max_speed -> air_speed_max:   float  'Maximum speed in air'
BoidSettings.air_min_speed -> air_speed_min:   float  'Minimum speed in air (relative to maximum speed)'
BoidSettings.air_personal_space -> air_personal_space:   float  'Radius of boids personal space in air (% of particle size)'
BoidSettings.allow_climb -> use_climb:   boolean  'Allow boids to climb goal objects'
BoidSettings.allow_flight -> use_flight:   boolean  'Allow boids to move in air'
BoidSettings.allow_land -> use_land:   boolean  'Allow boids to move on land'
BoidSettings.banking -> bank:   float  'Amount of rotation around velocity vector on turns'
BoidSettings.health -> health:   float  'Initial boid health when born'
BoidSettings.height -> height:   float  'Boid height relative to particle size'
BoidSettings.land_jump_speed -> land_jump_speed:   float  'Maximum speed for jumping'
BoidSettings.land_max_acc -> land_acc_max:   float  'Maximum acceleration on land (relative to maximum speed)'
BoidSettings.land_max_ave -> land_ave_max:   float  'Maximum angular velocity on land (relative to 180 degrees)'
BoidSettings.land_max_speed -> land_speed_max:   float  'Maximum speed on land'
BoidSettings.land_personal_space -> land_personal_space:   float  'Radius of boids personal space on land (% of particle size)'
BoidSettings.land_stick_force -> land_stick_force:   float  'How strong a force must be to start effecting a boid on land'
BoidSettings.landing_smoothness -> land_smooth:   float  'How smoothly the boids land'
BoidSettings.range -> range:   float  'The maximum distance from which a boid can attack'
BoidSettings.states -> states:   collection,  '(read-only)'
BoidSettings.strength -> strength:   float  'Maximum caused damage on attack per second'
BoidState.active_boid_rule -> active_boid_rule:   pointer,  '(read-only)'
BoidState.active_boid_rule_index -> active_boid_rule_index:   int  'NO DESCRIPTION'
BoidState.falloff -> falloff:   float  'NO DESCRIPTION'
BoidState.name -> name:   string  'Boid state name'
BoidState.rule_fuzziness -> rule_fuzzy:   float  'NO DESCRIPTION'
BoidState.rules -> rules:   collection,  '(read-only)'
BoidState.ruleset_type -> ruleset_type:   enum  'How the rules in the list are evaluated'
BoidState.volume -> volume:   float  'NO DESCRIPTION'
Bone.bbone_in -> bbone_in:   float  'Length of first Bezier Handle (for B-Bones only)'
Bone.bbone_out -> bbone_out:   float  'Length of second Bezier Handle (for B-Bones only)'
Bone.bbone_segments -> bbone_segments:   int  'Number of subdivisions of bone (for B-Bones only)'
Bone.children -> children:   collection,  '(read-only)    Bones which are children of this bone'
Bone.connected -> use_connect:   boolean,  "(read-only)    When bone has a parent, bone's head is struck to the parent's tail"
Bone.cyclic_offset -> use_cyclic_offset:   boolean  "When bone doesn't have a parent, it receives cyclic offset effects"
Bone.deform -> use_deform:   boolean  'Bone does not deform any geometry'
Bone.draw_wire -> show_wire:   boolean  'Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes'
Bone.envelope_distance -> envelope_distance:   float  'Bone deformation distance (for Envelope deform only)'
Bone.envelope_weight -> envelope_weight:   float  'Bone deformation weight (for Envelope deform only)'
Bone.head -> head:   float  'Location of head end of the bone relative to its parent'
Bone.head_local -> head_local:   float  'Location of head end of the bone relative to armature'
Bone.head_radius -> head_radius:   float  'Radius of head of bone (for Envelope deform only)'
Bone.hide -> hide:   boolean  'Bone is not visible when it is not in Edit Mode (i.e. in Object or Pose Modes)'
Bone.hide_select -> hide_select:   boolean  'Bone is able to be selected'
Bone.hinge -> use_hinge:   boolean  'Bone inherits rotation or scale from parent bone'
Bone.inherit_scale -> use_inherit_scale:   boolean  'Bone inherits scaling from parent bone'
Bone.layer -> layers:   boolean  'Layers bone exists in'
Bone.local_location -> use_local_location:   boolean  'Bone location is set in local space'
Bone.matrix -> matrix:   float  '3x3 bone matrix'
Bone.matrix_local -> matrix_local:   float  '4x4 bone matrix relative to armature'
Bone.multiply_vertexgroup_with_envelope -> use_envelope_multiply:   boolean  'When deforming bone, multiply effects of Vertex Group weights with Envelope influence'
Bone.name -> name:   string  'NO DESCRIPTION'
Bone.parent -> parent:   pointer,  '(read-only)    Parent bone (in same Armature)'
Bone.select -> select:   boolean  'NO DESCRIPTION'
Bone.tail -> tail:   float  'Location of tail end of the bone'
Bone.tail_local -> tail_local:   float  'Location of tail end of the bone relative to armature'
Bone.tail_radius -> tail_radius:   float  'Radius of tail of bone (for Envelope deform only)'
BoneGroup.color_set -> color_set:   enum  'Custom color set to use'
BoneGroup.colors -> colors:   pointer,  "(read-only)    Copy of the colors associated with the group's color set"
BoneGroup.name -> name:   string  'NO DESCRIPTION'
BooleanModifier.object -> object:   pointer  'Mesh object to use for Boolean operation'
BooleanModifier.operation -> operation:   enum  'NO DESCRIPTION'
BooleanProperty.array_length -> array_length:   int,  '(read-only)    Maximum length of the array, 0 means unlimited'
BooleanProperty.default -> default:   boolean,  '(read-only)    Default value for this number'
BooleanProperty.default_array -> default_array:   boolean,  '(read-only)    Default value for this array'
Brush.add_col -> add_col:   float  'Color of cursor when adding'
Brush.autosmooth_factor -> autosmooth_factor:   float  'Amount of smoothing to automatically apply to each stroke'
Brush.blend -> blend:   enum  'Brush blending mode'
Brush.clone_alpha -> clone_alpha:   float  'Opacity of clone image display'
Brush.clone_image -> clone_image:   pointer  'Image for clone tool'
Brush.clone_offset -> clone_offset:   float  'NO DESCRIPTION'
Brush.color -> color:   float  'NO DESCRIPTION'
Brush.crease_pinch_factor -> crease_pinch_factor:   float  'How much the crease brush pinches'
Brush.curve -> curve:   pointer,  '(read-only)    Editable falloff curve'
Brush.direction -> direction:   enum  'Mapping type to use for this image in the game engine'
Brush.edge_to_edge -> edge_to_edge:   boolean  'Drag anchor brush from edge-to-edge'
Brush.icon_filepath -> icon_filepath:   string  'File path to brush icon'
Brush.imagepaint_tool -> imagepaint_tool:   enum  'NO DESCRIPTION'
Brush.jitter -> jitter:   float  'Jitter the position of the brush while painting'
Brush.normal_weight -> normal_weight:   float  'How much grab will pull vertexes out of surface during a grab'
Brush.plane_offset -> plane_offset:   float  'Adjusts plane on which the brush acts towards or away from the object surface'
Brush.plane_trim -> plane_trim:   float  'If a vertex is further from offset plane than this then it is not affected'
Brush.rate -> rate:   float  'Interval between paints for Airbrush'
Brush.restore_mesh -> restore_mesh:   boolean  'Allows a single dot to be carefully positioned'
Brush.sculpt_plane -> sculpt_plane:   enum  'NO DESCRIPTION'
Brush.sculpt_tool -> sculpt_tool:   enum  'NO DESCRIPTION'
Brush.size -> size:   int  'Diameter of the brush'
Brush.smooth_stroke_factor -> smooth_stroke_factor:   float  'Higher values give a smoother stroke'
Brush.smooth_stroke_radius -> smooth_stroke_radius:   int  'Minimum distance from last point before stroke continues'
Brush.spacing -> spacing:   float  'Spacing between brush stamps'
Brush.strength -> strength:   float  'The amount of pressure on the brush'
Brush.stroke_method -> stroke_method:   enum  'NO DESCRIPTION'
Brush.sub_col -> sub_col:   float  'Color of cursor when subtracting'
Brush.texture -> texture:   pointer  'NO DESCRIPTION'
Brush.texture_angle_source -> texture_angle_source:   enum  'NO DESCRIPTION'
Brush.texture_angle_source_no_random -> texture_angle_source_no_random:   enum  'NO DESCRIPTION'
Brush.texture_overlay_alpha -> texture_overlay_alpha:   int  'NO DESCRIPTION'
Brush.texture_sample_bias -> texture_sample_bias:   float  'Value added to texture samples'
Brush.texture_slot -> texture_slot:   pointer,  '(read-only)'
Brush.unprojected_radius -> unprojected_radius:   float  'Radius of brush in Blender units'
Brush.use_accumulate -> use_accumulate:   boolean  'Accumulate stroke dabs on top of each other'
Brush.use_adaptive_space -> use_adaptive_space:   boolean  'Space daubs according to surface orientation instead of screen space'
Brush.use_airbrush -> use_airbrush:   boolean  'Keep applying paint effect while holding mouse (spray)'
Brush.use_alpha -> use_alpha:   boolean  'When this is disabled, lock alpha while painting'
Brush.use_anchor -> use_anchor:   boolean  'Keep the brush anchored to the initial location'
Brush.use_custom_icon -> use_custom_icon:   boolean  'Set the brush icon from an image file'
Brush.use_frontface -> use_frontface:   boolean  'Brush only affects vertexes that face the viewer'
Brush.use_inverse_smooth_pressure -> use_inverse_smooth_pressure:   boolean  'Lighter pressure causes more smoothing to be applied'
Brush.use_jitter_pressure -> use_pressure_jitter:   boolean  'Enable tablet pressure sensitivity for jitter'
Brush.use_locked_size -> use_locked_size:   boolean  'When locked brush stays same size relative to object; when unlocked brush size is given in pixels'
Brush.use_offset_pressure -> use_offset_pressure:   boolean  'Enable tablet pressure sensitivity for offset'
Brush.use_original_normal -> use_original_normal:   boolean  'When locked keep using normal of surface where stroke was initiated'
Brush.use_paint_sculpt -> use_paint_sculpt:   boolean  'Use this brush in sculpt mode'
Brush.use_paint_texture -> use_paint_texture:   boolean  'Use this brush in texture paint mode'
Brush.use_paint_vertex -> use_paint_vertex:   boolean  'Use this brush in vertex paint mode'
Brush.use_paint_weight -> use_paint_weight:   boolean  'Use this brush in weight paint mode'
Brush.use_persistent -> use_persistent:   boolean  'Sculpts on a persistent layer of the mesh'
Brush.use_plane_trim -> use_plane_trim:   boolean  'Enable Plane Trim'
Brush.use_rake -> use_rake:   boolean  'Rotate the brush texture to match the stroke direction'
Brush.use_random_rotation -> use_random_rotation:   boolean  'Rotate the brush texture at random'
Brush.use_size_pressure -> use_pressure_size:   boolean  'Enable tablet pressure sensitivity for size'
Brush.use_smooth_stroke -> use_smooth_stroke:   boolean  'Brush lags behind mouse and follows a smoother path'
Brush.use_space -> use_space:   boolean  'Limit brush application to the distance specified by spacing'
Brush.use_space_atten -> use_space_atten:   boolean  'Automatically adjusts strength to give consistent results for different spacings'
Brush.use_spacing_pressure -> use_pressure_spacing:   boolean  'Enable tablet pressure sensitivity for spacing'
Brush.use_strength_pressure -> use_pressure_strength:   boolean  'Enable tablet pressure sensitivity for strength'
Brush.use_texture_overlay -> use_texture_overlay:   boolean  'Show texture in viewport'
Brush.use_wrap -> use_wrap:   boolean  'Enable torus wrapping while painting'
Brush.vertexpaint_tool -> vertexpaint_tool:   enum  'NO DESCRIPTION'
BrushTextureSlot.angle -> angle:   float  'Defines brush texture rotation'
BrushTextureSlot.map_mode -> map_mode:   enum  'NO DESCRIPTION'
BuildModifier.frame_start -> frame_start:   float  'Specify the start frame of the effect'
BuildModifier.length -> length:   float  'Specify the total time the build effect requires'
BuildModifier.randomize -> use_random_order:   boolean  'Randomize the faces or edges during build'
BuildModifier.seed -> seed:   int  'Specify the seed for random if used'
Camera.angle -> angle:   float  'Perspective Camera lens field of view in degrees'
Camera.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
Camera.clip_end -> clip_end:   float  'Camera far clipping distance'
Camera.clip_start -> clip_start:   float  'Camera near clipping distance'
Camera.dof_distance -> dof_distance:   float  'Distance to the focus point for depth of field'
Camera.dof_object -> dof_object:   pointer  'Use this object to define the depth of field focal point'
Camera.draw_size -> draw_size:   float  'Apparent size of the Camera object in the 3D View'
Camera.lens -> lens:   float  'Perspective Camera lens value in millimeters'
Camera.lens_unit -> lens_unit:   enum  'Unit to edit lens in for the user interface'
Camera.ortho_scale -> ortho_scale:   float  'Orthographic Camera scale (similar to zoom)'
Camera.panorama -> use_panorama:   boolean  'Render the scene with a cylindrical camera for pseudo-fisheye lens effects'
Camera.passepartout_alpha -> passepartout_alpha:   float  'Opacity (alpha) of the darkened overlay in Camera view'
Camera.shift_x -> shift_x:   float  'Perspective Camera horizontal shift'
Camera.shift_y -> shift_y:   float  'Perspective Camera vertical shift'
Camera.show_limits -> show_limits:   boolean  'Draw the clipping range and focus point on the camera'
Camera.show_mist -> show_mist:   boolean  'Draw a line from the Camera to indicate the mist area'
Camera.show_name -> show_name:   boolean  "Show the active Camera's name in Camera view"
Camera.show_passepartout -> show_passepartout:   boolean  'Show a darkened overlay outside the image area in Camera view'
Camera.show_title_safe -> show_title_safe:   boolean  'Show indicators for the title safe zone in Camera view'
Camera.type -> type:   enum  'Camera types'
CameraActuator.axis -> axis:   enum  'Specify the axis the Camera will try to get behind'
CameraActuator.height -> height:   float  'NO DESCRIPTION'
CameraActuator.max -> max:   float  'NO DESCRIPTION'
CameraActuator.min -> min:   float  'NO DESCRIPTION'
CameraActuator.object -> object:   pointer  'Look at this Object'
CastModifier.cast_type -> cast_type:   enum  'NO DESCRIPTION'
CastModifier.factor -> factor:   float  'NO DESCRIPTION'
CastModifier.from_radius -> use_radius_as_size:   boolean  'Use radius as size of projection shape (0 = auto)'
CastModifier.object -> object:   pointer  'Control object: if available, its location determines the center of the effect'
CastModifier.radius -> radius:   float  'Only deform vertices within this distance from the center of the effect (leave as 0 for infinite.)'
CastModifier.size -> size:   float  'Size of projection shape (leave as 0 for auto.)'
CastModifier.use_transform -> use_transform:   boolean  'Use object transform to control projection shape'
CastModifier.vertex_group -> vertex_group:   string  'Vertex group name'
CastModifier.x -> use_x:   boolean  'NO DESCRIPTION'
CastModifier.y -> use_y:   boolean  'NO DESCRIPTION'
CastModifier.z -> use_z:   boolean  'NO DESCRIPTION'
ChildOfConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
ChildOfConstraint.target -> target:   pointer  'Target Object'
ChildOfConstraint.use_location_x -> use_location_x:   boolean  'Use X Location of Parent'
ChildOfConstraint.use_location_y -> use_location_y:   boolean  'Use Y Location of Parent'
ChildOfConstraint.use_location_z -> use_location_z:   boolean  'Use Z Location of Parent'
ChildOfConstraint.use_rotation_x -> use_rotation_x:   boolean  'Use X Rotation of Parent'
ChildOfConstraint.use_rotation_y -> use_rotation_y:   boolean  'Use Y Rotation of Parent'
ChildOfConstraint.use_rotation_z -> use_rotation_z:   boolean  'Use Z Rotation of Parent'
ChildOfConstraint.use_scale_x -> use_scale_x:   boolean  'Use X Scale of Parent'
ChildOfConstraint.use_scale_y -> use_scale_y:   boolean  'Use Y Scale of Parent'
ChildOfConstraint.use_scale_z -> use_scale_z:   boolean  'Use Z Scale of Parent'
ClampToConstraint.cyclic -> use_cyclic:   boolean  'Treat curve as cyclic curve (no clamping to curve bounding box'
ClampToConstraint.main_axis -> main_axis:   enum  'Main axis of movement'
ClampToConstraint.target -> target:   pointer  'Target Object'
ClothCollisionSettings.collision_quality -> collision_quality:   int  'How many collision iterations should be done. (higher is better quality but slower)'
ClothCollisionSettings.enable_collision -> use_collision:   boolean  'Enable collisions with other objects'
ClothCollisionSettings.enable_self_collision -> use_self_collision:   boolean  'Enable self collisions'
ClothCollisionSettings.friction -> friction:   float  'Friction force if a collision happened. (higher = less movement)'
ClothCollisionSettings.group -> group:   pointer  'Limit colliders to this Group'
ClothCollisionSettings.min_distance -> distance_min:   float  'Minimum distance between collision objects before collision response takes in'
ClothCollisionSettings.self_collision_quality -> self_collision_quality:   int  'How many self collision iterations should be done. (higher is better quality but slower)'
ClothCollisionSettings.self_friction -> self_friction:   float  'Friction/damping with self contact'
ClothCollisionSettings.self_min_distance -> self_distance_min:   float  '0.5 means no distance at all, 1.0 is maximum distance'
ClothModifier.collision_settings -> collision_settings:   pointer,  '(read-only)'
ClothModifier.point_cache -> point_cache:   pointer,  '(read-only)'
ClothModifier.settings -> settings:   pointer,  '(read-only)'
ClothSettings.air_damping -> air_damping:   float  'Air has normally some thickness which slows falling things down'
ClothSettings.bending_stiffness -> bending_stiffness:   float  'Wrinkle coefficient. (higher = less smaller but more big wrinkles)'
ClothSettings.bending_stiffness_max -> bending_stiffness_max:   float  'Maximum bending stiffness value'
ClothSettings.bending_vertex_group -> bending_vertex_group:   string  'Vertex group for fine control over bending stiffness'
ClothSettings.collider_friction -> collider_friction:   float  'NO DESCRIPTION'
ClothSettings.effector_weights -> effector_weights:   pointer,  '(read-only)'
ClothSettings.goal_default -> goal_default:   float  'Default Goal (vertex target position) value, when no Vertex Group used'
ClothSettings.goal_friction -> goal_friction:   float  'Goal (vertex target position) friction'
ClothSettings.goal_max -> goal_max:   float  'Goal maximum, vertex group weights are scaled to match this range'
ClothSettings.goal_min -> goal_min:   float  'Goal minimum, vertex group weights are scaled to match this range'
ClothSettings.goal_spring -> goal_spring:   float  'Goal (vertex target position) spring stiffness'
ClothSettings.gravity -> gravity:   float  'Gravity or external force vector'
ClothSettings.internal_friction -> internal_friction:   float  'NO DESCRIPTION'
ClothSettings.mass -> mass:   float  'Mass of cloth material'
ClothSettings.mass_vertex_group -> mass_vertex_group:   string  'Vertex Group for pinning of vertices'
ClothSettings.pin_cloth -> use_pin_cloth:   boolean  'Enable pinning of cloth vertices to other objects/positions'
ClothSettings.pin_stiffness -> pin_stiffness:   float  'Pin (vertex target position) spring stiffness'
ClothSettings.pre_roll -> pre_roll:   int  'Simulation starts on this frame'
ClothSettings.quality -> quality:   int  'Quality of the simulation in steps per frame. (higher is better quality but slower)'
ClothSettings.rest_shape_key -> rest_shape_key:   pointer  'Shape key to use the rest spring lengths from'
ClothSettings.spring_damping -> spring_damping:   float  'Damping of cloth velocity. (higher = more smooth, less jiggling)'
ClothSettings.stiffness_scaling -> use_stiffness_scale:   boolean  'If enabled, stiffness can be scaled along a weight painted vertex group'
ClothSettings.structural_stiffness -> structural_stiffness:   float  'Overall stiffness of structure'
ClothSettings.structural_stiffness_max -> structural_stiffness_max:   float  'Maximum structural stiffness value'
ClothSettings.structural_stiffness_vertex_group -> structural_stiffness_vertex_group:   string  'Vertex group for fine control over structural stiffness'
CloudsTexture.nabla -> nabla:   float  'Size of derivative offset used for calculating normal'
CloudsTexture.noise_basis -> noise_basis:   enum  'Sets the noise basis used for turbulence'
CloudsTexture.noise_depth -> noise_depth:   int  'Sets the depth of the cloud calculation'
CloudsTexture.noise_size -> noise_size:   float  'Sets scaling for noise input'
CloudsTexture.noise_type -> noise_type:   enum  'NO DESCRIPTION'
CloudsTexture.stype -> stype:   enum  'NO DESCRIPTION'
CollectionProperty.fixed_type -> fixed_type:   pointer,  '(read-only)    Fixed pointer type, empty if variable type'
CollisionModifier.settings -> settings:   pointer,  '(read-only)'
CollisionSensor.collision_type -> use_material:   boolean  'Use material instead of property'
CollisionSensor.material -> material:   string  'Only look for Objects with this material'
CollisionSensor.property -> property:   string  'Only look for Objects with this property'
CollisionSensor.pulse -> use_pulse:   boolean  'Changes to the set of colliding objects generates pulse'
CollisionSettings.absorption -> absorption:   float  'How much of effector force gets lost during collision with this object (in percent)'
CollisionSettings.damping -> damping:   float  'Amount of damping during collision'
CollisionSettings.damping_factor -> damping_factor:   float  'Amount of damping during particle collision'
CollisionSettings.enabled -> use:   boolean  'Enable this objects as a collider for physics systems'
CollisionSettings.friction_factor -> friction_factor:   float  'Amount of friction during particle collision'
CollisionSettings.inner_thickness -> inner_thickness:   float  'Inner face thickness'
CollisionSettings.kill_particles -> use_particle_kill:   boolean  'Kill colliding particles'
CollisionSettings.outer_thickness -> outer_thickness:   float  'Outer face thickness'
CollisionSettings.permeability -> permeability:   float  'Chance that the particle will pass through the mesh'
CollisionSettings.random_damping -> random_damping:   float  'Random variation of damping'
CollisionSettings.random_friction -> random_friction:   float  'Random variation of friction'
CollisionSettings.stickness -> stickness:   float  'Amount of stickness to surface collision'
ColorRamp.elements -> elements:   collection,  '(read-only)'
ColorRamp.interpolation -> interpolation:   enum  'NO DESCRIPTION'
ColorRamp.total -> total:   int,  '(read-only)    Total number of elements'
ColorRampElement.color -> color:   float  'NO DESCRIPTION'
ColorRampElement.position -> position:   float  'NO DESCRIPTION'
ColorSequence.color -> color:   float  'NO DESCRIPTION'
CompositorNode.type -> type:   enum,  '(read-only)'
CompositorNodeAlphaOver.convert_premul -> use_premultiply:   boolean  'NO DESCRIPTION'
CompositorNodeAlphaOver.premul -> premul:   float  'Mix Factor'
CompositorNodeBilateralblur.iterations -> iterations:   int  'NO DESCRIPTION'
CompositorNodeBilateralblur.sigma_color -> sigma_color:   float  'NO DESCRIPTION'
CompositorNodeBilateralblur.sigma_space -> sigma_space:   float  'NO DESCRIPTION'
CompositorNodeBlur.bokeh -> use_bokeh:   boolean  'NO DESCRIPTION'
CompositorNodeBlur.factor -> factor:   float  'NO DESCRIPTION'
CompositorNodeBlur.factor_x -> factor_x:   float  'NO DESCRIPTION'
CompositorNodeBlur.factor_y -> factor_y:   float  'NO DESCRIPTION'
CompositorNodeBlur.filter_type -> filter_type:   enum  'NO DESCRIPTION'
CompositorNodeBlur.gamma -> use_gamma_correction:   boolean  'NO DESCRIPTION'
CompositorNodeBlur.relative -> use_relative:   boolean  'NO DESCRIPTION'
CompositorNodeBlur.sizex -> size_x:   int  'NO DESCRIPTION'
CompositorNodeBlur.sizey -> size_y:   int  'NO DESCRIPTION'
CompositorNodeChannelMatte.algorithm -> algorithm:   enum  'Algorithm to use to limit channel'
CompositorNodeChannelMatte.channel -> channel:   enum  'Channel used to determine matte'
CompositorNodeChannelMatte.color_space -> color_space:   enum  'NO DESCRIPTION'
CompositorNodeChannelMatte.high -> high:   float  'Values higher than this setting are 100% opaque'
CompositorNodeChannelMatte.limit_channel -> limit_channel:   enum  'Limit by this channels value'
CompositorNodeChannelMatte.low -> low:   float  'Values lower than this setting are 100% keyed'
CompositorNodeChromaMatte.acceptance -> acceptance:   float  'Tolerance for a color to be considered a keying color'
CompositorNodeChromaMatte.cutoff -> cutoff:   float  'Tolerance below which colors will be considered as exact matches'
CompositorNodeChromaMatte.gain -> gain:   float  'Alpha gain'
CompositorNodeChromaMatte.lift -> lift:   float  'Alpha lift'
CompositorNodeChromaMatte.shadow_adjust -> shadow_adjust:   float  'Adjusts the brightness of any shadows captured'
CompositorNodeColorBalance.correction_formula -> correction_formula:   enum  'NO DESCRIPTION'
CompositorNodeColorBalance.gain -> gain:   float  'Correction for Highlights'
CompositorNodeColorBalance.gamma -> gamma:   float  'Correction for Midtones'
CompositorNodeColorBalance.lift -> lift:   float  'Correction for Shadows'
CompositorNodeColorBalance.offset -> offset:   float  'Correction for Shadows'
CompositorNodeColorBalance.power -> power:   float  'Correction for Midtones'
CompositorNodeColorBalance.slope -> slope:   float  'Correction for Highlights'
CompositorNodeColorMatte.h -> h:   float  'Hue tolerance for colors to be considered a keying color'
CompositorNodeColorMatte.s -> s:   float  'Saturation Tolerance for the color'
CompositorNodeColorMatte.v -> v:   float  'Value Tolerance for the color'
CompositorNodeColorSpill.algorithm -> algorithm:   enum  'NO DESCRIPTION'
CompositorNodeColorSpill.channel -> channel:   enum  'NO DESCRIPTION'
CompositorNodeColorSpill.limit_channel -> limit_channel:   enum  'NO DESCRIPTION'
CompositorNodeColorSpill.ratio -> ratio:   float  'Scale limit by value'
CompositorNodeColorSpill.unspill -> use_unspill:   boolean  'Compensate all channels (diffenrently) by hand'
CompositorNodeColorSpill.unspill_blue -> unspill_blue:   float  'Blue spillmap scale'
CompositorNodeColorSpill.unspill_green -> unspill_green:   float  'Green spillmap scale'
CompositorNodeColorSpill.unspill_red -> unspill_red:   float  'Red spillmap scale'
CompositorNodeCrop.crop_size -> use_crop_size:   boolean  'Whether to crop the size of the input image'
CompositorNodeCrop.x1 -> x1:   int  'NO DESCRIPTION'
CompositorNodeCrop.x2 -> x2:   int  'NO DESCRIPTION'
CompositorNodeCrop.y1 -> y1:   int  'NO DESCRIPTION'
CompositorNodeCrop.y2 -> y2:   int  'NO DESCRIPTION'
CompositorNodeCurveRGB.mapping -> mapping:   pointer,  '(read-only)'
CompositorNodeCurveVec.mapping -> mapping:   pointer,  '(read-only)'
CompositorNodeDBlur.angle -> angle:   float  'NO DESCRIPTION'
CompositorNodeDBlur.center_x -> center_x:   float  'NO DESCRIPTION'
CompositorNodeDBlur.center_y -> center_y:   float  'NO DESCRIPTION'
CompositorNodeDBlur.distance -> distance:   float  'NO DESCRIPTION'
CompositorNodeDBlur.iterations -> iterations:   int  'NO DESCRIPTION'
CompositorNodeDBlur.spin -> spin:   float  'NO DESCRIPTION'
CompositorNodeDBlur.wrap -> use_wrap:   boolean  'NO DESCRIPTION'
CompositorNodeDBlur.zoom -> zoom:   float  'NO DESCRIPTION'
CompositorNodeDefocus.angle -> angle:   int  'Bokeh shape rotation offset in degrees'
CompositorNodeDefocus.bokeh -> bokeh:   enum  'NO DESCRIPTION'
CompositorNodeDefocus.f_stop -> f_stop:   float  'Amount of focal blur, 128=infinity=perfect focus, half the value doubles the blur radius'
CompositorNodeDefocus.gamma_correction -> use_gamma_correction:   boolean  'Enable gamma correction before and after main process'
CompositorNodeDefocus.max_blur -> blur_max:   float  'blur limit, maximum CoC radius, 0=no limit'
CompositorNodeDefocus.preview -> use_preview:   boolean  'Enable sampling mode, useful for preview when using low samplecounts'
CompositorNodeDefocus.samples -> samples:   int  'Number of samples (16=grainy, higher=less noise)'
CompositorNodeDefocus.threshold -> threshold:   float  'CoC radius threshold, prevents background bleed on in-focus midground, 0=off'
CompositorNodeDefocus.use_zbuffer -> use_zbuffer:   boolean  'Disable when using an image as input instead of actual zbuffer (auto enabled if node not image based, eg. time node)'
CompositorNodeDefocus.z_scale -> z_scale:   float  'Scales the Z input when not using a zbuffer, controls maximum blur designated by the color white or input value 1'
CompositorNodeDiffMatte.falloff -> falloff:   float  'Color distances below this additional threshold are partially keyed'
CompositorNodeDiffMatte.tolerance -> tolerance:   float  'Color distances below this threshold are keyed'
CompositorNodeDilateErode.distance -> distance:   int  'Distance to grow/shrink (number of iterations)'
CompositorNodeDistanceMatte.falloff -> falloff:   float  'Color distances below this additional threshold are partially keyed'
CompositorNodeDistanceMatte.tolerance -> tolerance:   float  'Color distances below this threshold are keyed'
CompositorNodeFilter.filter_type -> filter_type:   enum  'NO DESCRIPTION'
CompositorNodeFlip.axis -> axis:   enum  'NO DESCRIPTION'
CompositorNodeGlare.angle_offset -> angle_offset:   float  'Streak angle offset in degrees'
CompositorNodeGlare.color_modulation -> color_modulation:   float  'Amount of Color Modulation, modulates colors of streaks and ghosts for a spectral dispersion effect'
CompositorNodeGlare.fade -> fade:   float  'Streak fade-out factor'
CompositorNodeGlare.glare_type -> glare_type:   enum  'NO DESCRIPTION'
CompositorNodeGlare.iterations -> iterations:   int  'NO DESCRIPTION'
CompositorNodeGlare.mix -> mix:   float  '-1 is original image only, 0 is exact 50/50 mix, 1 is processed image only'
CompositorNodeGlare.quality -> quality:   enum  'If not set to high quality, the effect will be applied to a low-res copy of the source image'
CompositorNodeGlare.rotate_45 -> use_rotate_45:   boolean  'Simple star filter: add 45 degree rotation offset'
CompositorNodeGlare.size -> size:   int  'Glow/glare size (not actual size; relative to initial size of bright area of pixels)'
CompositorNodeGlare.streaks -> streaks:   int  'Total number of streaks'
CompositorNodeGlare.threshold -> threshold:   float  'The glare filter will only be applied to pixels brighter than this value'
CompositorNodeHueCorrect.mapping -> mapping:   pointer,  '(read-only)'
CompositorNodeHueSat.hue -> hue:   float  'NO DESCRIPTION'
CompositorNodeHueSat.sat -> sat:   float  'NO DESCRIPTION'
CompositorNodeHueSat.val -> val:   float  'NO DESCRIPTION'
CompositorNodeIDMask.index -> index:   int  'Pass index number to convert to alpha'
CompositorNodeImage.auto_refresh -> use_auto_refresh:   boolean  'NO DESCRIPTION'
CompositorNodeImage.cyclic -> use_cyclic:   boolean  'NO DESCRIPTION'
CompositorNodeImage.frames -> frames:   int  'Number of images used in animation'
CompositorNodeImage.image -> image:   pointer  'NO DESCRIPTION'
CompositorNodeImage.layer -> layer:   enum  'NO DESCRIPTION'
CompositorNodeImage.offset -> offset:   int  'Offsets the number of the frame to use in the animation'
CompositorNodeImage.start -> start:   int  'NO DESCRIPTION'
CompositorNodeInvert.alpha -> invert_alpha:   boolean  'NO DESCRIPTION'
CompositorNodeInvert.rgb -> invert_rgb:   boolean  'NO DESCRIPTION'
CompositorNodeLensdist.fit -> use_fit:   boolean  'For positive distortion factor only: scale image such that black areas are not visible'
CompositorNodeLensdist.jitter -> use_jitter:   boolean  'Enable/disable jittering; faster, but also noisier'
CompositorNodeLensdist.projector -> use_projector:   boolean  'Enable/disable projector mode. Effect is applied in horizontal direction only'
CompositorNodeLevels.channel -> channel:   enum  'NO DESCRIPTION'
CompositorNodeLumaMatte.high -> high:   float  'Values higher than this setting are 100% opaque'
CompositorNodeLumaMatte.low -> low:   float  'Values lower than this setting are 100% keyed'
CompositorNodeMapUV.alpha -> alpha:   int  'NO DESCRIPTION'
CompositorNodeMapValue.max -> max:   float  'NO DESCRIPTION'
CompositorNodeMapValue.min -> min:   float  'NO DESCRIPTION'
CompositorNodeMapValue.offset -> offset:   float  'NO DESCRIPTION'
CompositorNodeMapValue.size -> size:   float  'NO DESCRIPTION'
CompositorNodeMapValue.use_max -> use_max:   boolean  'NO DESCRIPTION'
CompositorNodeMapValue.use_min -> use_min:   boolean  'NO DESCRIPTION'
CompositorNodeMath.operation -> operation:   enum  'NO DESCRIPTION'
CompositorNodeMixRGB.alpha -> use_alpha:   boolean  'Include alpha of second input in this operation'
CompositorNodeMixRGB.blend_type -> blend_type:   enum  'NO DESCRIPTION'
CompositorNodeOutputFile.exr_codec -> exr_codec:   enum  'NO DESCRIPTION'
CompositorNodeOutputFile.exr_half -> use_exr_half:   boolean  'NO DESCRIPTION'
CompositorNodeOutputFile.filepath -> filepath:   string  'Output path for the image, same functionality as render output.'
CompositorNodeOutputFile.frame_end -> frame_end:   int  'NO DESCRIPTION'
CompositorNodeOutputFile.frame_start -> frame_start:   int  'NO DESCRIPTION'
CompositorNodeOutputFile.image_type -> image_type:   enum  'NO DESCRIPTION'
CompositorNodeOutputFile.quality -> quality:   int  'NO DESCRIPTION'
CompositorNodePremulKey.mapping -> mapping:   enum  'Conversion between premultiplied alpha and key alpha'
CompositorNodeRLayers.layer -> layer:   enum  'NO DESCRIPTION'
CompositorNodeRLayers.scene -> scene:   pointer  'NO DESCRIPTION'
CompositorNodeRotate.filter -> filter:   enum  'Method to use to filter rotation'
CompositorNodeScale.space -> space:   enum  'Coordinate space to scale relative to'
CompositorNodeSplitViewer.axis -> axis:   enum  'NO DESCRIPTION'
CompositorNodeSplitViewer.factor -> factor:   int  'NO DESCRIPTION'
CompositorNodeTexture.node_output -> node_output:   int  'For node-based textures, which output node to use'
CompositorNodeTexture.texture -> texture:   pointer  'NO DESCRIPTION'
CompositorNodeTime.curve -> curve:   pointer,  '(read-only)'
CompositorNodeTime.end -> end:   int  'NO DESCRIPTION'
CompositorNodeTime.start -> start:   int  'NO DESCRIPTION'
CompositorNodeTonemap.adaptation -> adaptation:   float  'If 0, global; if 1, based on pixel intensity'
CompositorNodeTonemap.contrast -> contrast:   float  'Set to 0 to use estimate from input image'
CompositorNodeTonemap.correction -> correction:   float  'If 0, same for all channels; if 1, each independent'
CompositorNodeTonemap.gamma -> gamma:   float  'If not used, set to 1'
CompositorNodeTonemap.intensity -> intensity:   float  'If less than zero, darkens image; otherwise, makes it brighter'
CompositorNodeTonemap.key -> key:   float  'The value the average luminance is mapped to'
CompositorNodeTonemap.offset -> offset:   float  'Normally always 1, but can be used as an extra control to alter the brightness curve'
CompositorNodeTonemap.tonemap_type -> tonemap_type:   enum  'NO DESCRIPTION'
CompositorNodeValToRGB.color_ramp -> color_ramp:   pointer,  '(read-only)'
CompositorNodeVecBlur.curved -> use_curved:   boolean  'Interpolate between frames in a bezier curve, rather than linearly'
CompositorNodeVecBlur.factor -> factor:   float  "Scaling factor for motion vectors; actually 'shutter speed' in frames"
CompositorNodeVecBlur.max_speed -> speed_max:   int  'Maximum speed, or zero for none'
CompositorNodeVecBlur.min_speed -> speed_min:   int  'Minimum speed for a pixel to be blurred; used to separate background from foreground'
CompositorNodeVecBlur.samples -> samples:   int  'NO DESCRIPTION'
ConsoleLine.current_character -> current_character:   int  'NO DESCRIPTION'
ConsoleLine.line -> line:   string  'Text in the line'
Constraint.active -> active:   boolean  'Constraint is the one being edited'
Constraint.disabled -> is_valid:   boolean,  '(read-only)    Constraint has invalid settings and will not be evaluated'
Constraint.enabled -> enabled:   boolean  'Enable/Disable Constraint'
Constraint.expanded -> show_expanded:   boolean  "Constraint's panel is expanded in UI"
Constraint.influence -> influence:   float  'Amount of influence constraint will have on the final solution'
Constraint.lin_error -> lin_error:   float,  '(read-only)    Amount of residual error in Blender space unit for constraints that work on position'
Constraint.name -> name:   string  'Constraint name'
Constraint.owner_space -> owner_space:   enum  'Space that owner is evaluated in'
Constraint.proxy_local -> is_proxy_local:   boolean  'Constraint was added in this proxy instance (i.e. did not belong to source Armature)'
Constraint.rot_error -> rot_error:   float,  '(read-only)    Amount of residual error in radiant for constraints that work on orientation'
Constraint.target_space -> target_space:   enum  'Space that target is evaluated in'
Constraint.type -> type:   enum,  '(read-only)'
ConstraintActuator.damping -> damping:   int  'Damping factor: time constant (in frame) of low pass filter'
ConstraintActuator.damping_rotation -> damping_rotation:   int  'Use a different damping for orientation'
ConstraintActuator.detect_material -> use_material_detect:   boolean  'Detect material instead of property'
ConstraintActuator.direction -> direction:   enum  'Set the direction of the ray'
ConstraintActuator.direction_axis -> direction_axis:   enum  'Select the axis to be aligned along the reference direction'
ConstraintActuator.distance -> distance:   float  'Set the maximum length of ray'
ConstraintActuator.fh_damping -> fh_damping:   float  'Damping factor of the Fh spring force'
ConstraintActuator.fh_height -> fh_height:   float  'Height of the Fh area'
ConstraintActuator.fh_normal -> use_fh_normal:   boolean  'Add a horizontal spring force on slopes'
ConstraintActuator.fh_paralel_axis -> use_fh_paralel_axis:   boolean  'Keep object axis parallel to normal'
ConstraintActuator.force_distance -> use_force_distance:   boolean  'Force distance of object to point of impact of ray'
ConstraintActuator.limit -> limit:   enum  'NO DESCRIPTION'
ConstraintActuator.limit_max -> limit_max:   float  'NO DESCRIPTION'
ConstraintActuator.limit_min -> limit_min:   float  'NO DESCRIPTION'
ConstraintActuator.local -> use_local:   boolean  "Set ray along object's axis or global axis"
ConstraintActuator.material -> material:   string  'Ray detects only Objects with this material'
ConstraintActuator.max_angle -> angle_max:   float  'Maximum angle (in degree) allowed with target direction. No correction is done if angle with target direction is between min and max'
ConstraintActuator.max_rotation -> rotation_max:   float  'Reference Direction'
ConstraintActuator.min_angle -> angle_min:   float  'Minimum angle (in degree) to maintain with target direction. No correction is done if angle with target direction is between min and max'
ConstraintActuator.mode -> mode:   enum  'The type of the constraint'
ConstraintActuator.normal -> use_normal:   boolean  'Set object axis along (local axis) or parallel (global axis) to the normal at hit position'
ConstraintActuator.persistent -> use_persistent:   boolean  'Persistent actuator: stays active even if ray does not reach target'
ConstraintActuator.property -> property:   string  'Ray detect only Objects with this property'
ConstraintActuator.range -> range:   float  'Set the maximum length of ray'
ConstraintActuator.spring -> spring:   float  'Spring force within the Fh area'
ConstraintActuator.time -> time:   int  'Maximum activation time in frame, 0 for unlimited'
ConstraintTarget.subtarget -> subtarget:   string  'NO DESCRIPTION'
ConstraintTarget.target -> target:   pointer  'Target Object'
Context.area -> area:   pointer,  '(read-only)'
Context.main -> main:   pointer,  '(read-only)'
Context.manager -> manager:   pointer,  '(read-only)'
Context.mode -> mode:   enum,  '(read-only)'
Context.region -> region:   pointer,  '(read-only)'
Context.region_data -> region_data:   pointer,  '(read-only)'
Context.scene -> scene:   pointer,  '(read-only)'
Context.screen -> screen:   pointer,  '(read-only)'
Context.space_data -> space_data:   pointer,  '(read-only)'
Context.tool_settings -> tool_settings:   pointer,  '(read-only)'
Context.user_preferences -> user_preferences:   pointer,  '(read-only)'
Context.window -> window:   pointer,  '(read-only)'
ControlFluidSettings.active -> use:   boolean  'Object contributes to the fluid simulation'
ControlFluidSettings.attraction_radius -> attraction_radius:   float  'Specifies the force field radius around the control object'
ControlFluidSettings.attraction_strength -> attraction_strength:   float  'Force strength for directional attraction towards the control object'
ControlFluidSettings.end_time -> end_time:   float  'Specifies time when the control particles are deactivated'
ControlFluidSettings.quality -> quality:   float  'Specifies the quality which is used for object sampling. (higher = better but slower)'
ControlFluidSettings.reverse_frames -> use_reverse_frames:   boolean  'Reverse control object movement'
ControlFluidSettings.start_time -> start_time:   float  'Specifies time when the control particles are activated'
ControlFluidSettings.velocity_radius -> velocity_radius:   float  'Specifies the force field radius around the control object'
ControlFluidSettings.velocity_strength -> velocity_strength:   float  "Force strength of how much of the control object's velocity is influencing the fluid velocity"
Controller.expanded -> show_expanded:   boolean  'Set controller expanded in the user interface'
Controller.name -> name:   string  'NO DESCRIPTION'
Controller.priority -> use_priority:   boolean  'Mark controller for execution before all non-marked controllers (good for startup scripts)'
Controller.state -> states:   boolean,  '(read-only)    Set Controller state index (1 to 30)'
Controller.type -> type:   enum  'NO DESCRIPTION'
CopyLocationConstraint.head_tail -> head_tail:   float  'Target along length of bone: Head=0, Tail=1'
CopyLocationConstraint.invert_x -> invert_x:   boolean  'Invert the X location'
CopyLocationConstraint.invert_y -> invert_y:   boolean  'Invert the Y location'
CopyLocationConstraint.invert_z -> invert_z:   boolean  'Invert the Z location'
CopyLocationConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
CopyLocationConstraint.target -> target:   pointer  'Target Object'
CopyLocationConstraint.use_offset -> use_offset:   boolean  'Add original location into copied location'
CopyLocationConstraint.use_x -> use_x:   boolean  "Copy the target's X location"
CopyLocationConstraint.use_y -> use_y:   boolean  "Copy the target's Y location"
CopyLocationConstraint.use_z -> use_z:   boolean  "Copy the target's Z location"
CopyRotationConstraint.invert_x -> invert_x:   boolean  'Invert the X rotation'
CopyRotationConstraint.invert_y -> invert_y:   boolean  'Invert the Y rotation'
CopyRotationConstraint.invert_z -> invert_z:   boolean  'Invert the Z rotation'
CopyRotationConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
CopyRotationConstraint.target -> target:   pointer  'Target Object'
CopyRotationConstraint.use_offset -> use_offset:   boolean  'Add original rotation into copied rotation'
CopyRotationConstraint.use_x -> use_x:   boolean  "Copy the target's X rotation"
CopyRotationConstraint.use_y -> use_y:   boolean  "Copy the target's Y rotation"
CopyRotationConstraint.use_z -> use_z:   boolean  "Copy the target's Z rotation"
CopyScaleConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
CopyScaleConstraint.target -> target:   pointer  'Target Object'
CopyScaleConstraint.use_offset -> use_offset:   boolean  'Add original scale into copied scale'
CopyScaleConstraint.use_x -> use_x:   boolean  "Copy the target's X scale"
CopyScaleConstraint.use_y -> use_y:   boolean  "Copy the target's Y scale"
CopyScaleConstraint.use_z -> use_z:   boolean  "Copy the target's Z scale"
CopyTransformsConstraint.head_tail -> head_tail:   float  'Target along length of bone: Head=0, Tail=1'
CopyTransformsConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
CopyTransformsConstraint.target -> target:   pointer  'Target Object'
Curve.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
Curve.auto_texspace -> use_auto_texspace:   boolean  "Adjusts active object's texture space automatically when transforming object"
Curve.back -> use_fill_back:   boolean  'Draw filled back for extruded/beveled curves'
Curve.bevel_depth -> bevel_depth:   float  'Bevel depth when not using a bevel object'
Curve.bevel_object -> bevel_object:   pointer  'Curve object name that defines the bevel shape'
Curve.bevel_resolution -> bevel_resolution:   int  'Bevel resolution when depth is non-zero and no specific bevel object has been defined'
Curve.dimensions -> dimensions:   enum  'Select 2D or 3D curve type'
Curve.draw_handles -> show_handles:   boolean  'Display bezier handles in editmode'
Curve.draw_normals -> show_normals:   boolean  'Display 3D curve normals in editmode'
Curve.eval_time -> eval_time:   float  "Parametric position along the length of the curve that Objects 'following' it should be at. Position is evaluated by dividing by the 'Path Length' value"
Curve.extrude -> extrude:   float  'Amount of curve extrusion when not using a bevel object'
Curve.front -> use_fill_front:   boolean  'Draw filled front for extruded/beveled curves'
Curve.map_along_length -> use_map_along_length:   boolean  'Generate texture mapping coordinates following the curve direction, rather than the local bounding box'
Curve.materials -> materials:   collection,  '(read-only)'
Curve.path_length -> path_length:   int  "The number of frames that are needed to traverse the path, defining the maximum value for the 'Evaluation Time' setting"
Curve.render_resolution_u -> render_resolution_u:   int  'Surface resolution in U direction used while rendering. Zero skips this property'
Curve.render_resolution_v -> render_resolution_v:   int  'Surface resolution in V direction used while rendering. Zero skips this property'
Curve.resolution_u -> resolution_u:   int  'Surface resolution in U direction'
Curve.resolution_v -> resolution_v:   int  'Surface resolution in V direction'
Curve.shape_keys -> shape_keys:   pointer,  '(read-only)'
Curve.splines -> splines:   collection,  '(read-only)    Collection of splines in this curve data object'
Curve.taper_object -> taper_object:   pointer  'Curve object name that defines the taper (width)'
Curve.texspace_loc -> texspace_loc:   float  'Texture space location'
Curve.texspace_size -> texspace_size:   float  'Texture space size'
Curve.twist_mode -> twist_mode:   enum  'The type of tilt calculation for 3D Curves'
Curve.twist_smooth -> twist_smooth:   float  'Smoothing iteration for tangents'
Curve.use_deform_bounds -> use_deform_bounds:   boolean  'Use the mesh bounds to clamp the deformation'
Curve.use_deform_fill -> use_fill_deform:   boolean  'Fill curve after applying deformation'
Curve.use_path -> use_path:   boolean  'Enable the curve to become a translation path'
Curve.use_path_follow -> use_path_follow:   boolean  'Make curve path children to rotate along the path'
Curve.use_radius -> use_radius:   boolean  'Option for paths: apply the curve radius with path following it and deforming'
Curve.use_stretch -> use_stretch:   boolean  'Option for curve-deform: makes deformed child to stretch along entire path'
Curve.use_time_offset -> use_time_offset:   boolean  'Children will use Time Offset value as path distance offset'
Curve.width -> width:   float  'Scale the original width (1.0) based on given factor'
CurveMap.extend -> extend:   enum,  '(read-only)    Extrapolate the curve or extend it horizontally'
CurveMap.points -> points:   collection,  '(read-only)'
CurveMapPoint.handle_type -> handle_type:   enum,  '(read-only)    Curve interpolation at this point: bezier or vector'
CurveMapPoint.location -> location:   float,  '(read-only)    X/Y coordinates of the curve point'
CurveMapPoint.select -> select:   boolean  'Selection state of the curve point'
CurveMapping.black_level -> black_level:   float  'For RGB curves, the color that black is mapped to'
CurveMapping.clip -> use_clip:   boolean  'Force the curve view to fit a defined boundary'
CurveMapping.clip_max_x -> clip_max_x:   float  'NO DESCRIPTION'
CurveMapping.clip_max_y -> clip_max_y:   float  'NO DESCRIPTION'
CurveMapping.clip_min_x -> clip_min_x:   float  'NO DESCRIPTION'
CurveMapping.clip_min_y -> clip_min_y:   float  'NO DESCRIPTION'
CurveMapping.curves -> curves:   collection,  '(read-only)'
CurveMapping.white_level -> white_level:   float  'For RGB curves, the color that white is mapped to'
CurveModifier.deform_axis -> deform_axis:   enum  'The axis that the curve deforms along'
CurveModifier.object -> object:   pointer  'Curve object to deform with'
CurveModifier.vertex_group -> vertex_group:   string  'Vertex group name'
CurveSplines.active -> active:   pointer  'Active curve spline'
DampedTrackConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
DampedTrackConstraint.target -> target:   pointer  'Target Object'
DampedTrackConstraint.track -> track:   enum  'Axis that points to the target object'
DecimateModifier.face_count -> face_count:   int,  '(read-only)    The current number of faces in the decimated mesh'
DecimateModifier.ratio -> ratio:   float  'Defines the ratio of triangles to reduce to'
DelaySensor.delay -> delay:   int  'Delay in number of logic tics before the positive trigger (default 60 per second)'
DelaySensor.duration -> duration:   int  'If >0, delay in number of logic tics before the negative trigger following the positive trigger'
DelaySensor.repeat -> use_repeat:   boolean  'Toggle repeat option. If selected, the sensor restarts after Delay+Dur logic tics'
DisplaceModifier.direction -> direction:   enum  'NO DESCRIPTION'
DisplaceModifier.midlevel -> midlevel:   float  'Material value that gives no displacement'
DisplaceModifier.strength -> strength:   float  'NO DESCRIPTION'
DisplaceModifier.texture -> texture:   pointer  'NO DESCRIPTION'
DisplaceModifier.texture_coordinate_object -> texture_coordinate_object:   pointer  'NO DESCRIPTION'
DisplaceModifier.texture_coordinates -> texture_coordinates:   enum  'NO DESCRIPTION'
DisplaceModifier.uv_layer -> uv_layer:   string  'UV layer name'
DisplaceModifier.vertex_group -> vertex_group:   string  'Vertex group name'
DistortedNoiseTexture.distortion -> distortion:   float  'NO DESCRIPTION'
DistortedNoiseTexture.nabla -> nabla:   float  'Size of derivative offset used for calculating normal'
DistortedNoiseTexture.noise_basis -> noise_basis:   enum  'Sets the noise basis used for turbulence'
DistortedNoiseTexture.noise_distortion -> noise_distortion:   enum  'Sets the noise basis for the distortion'
DistortedNoiseTexture.noise_size -> noise_size:   float  'Sets scaling for noise input'
DomainFluidSettings.compressibility -> compressibility:   float  'Allowed compressibility due to gravitational force for standing fluid. (directly affects simulation step size)'
DomainFluidSettings.end_time -> end_time:   float  'Simulation time of the last blender frame'
DomainFluidSettings.generate_particles -> generate_particles:   float  'Amount of particles to generate (0=off, 1=normal, >1=more)'
DomainFluidSettings.generate_speed_vectors -> use_speed_vectors:   boolean  'Generate speed vectors for vector blur'
DomainFluidSettings.gravity -> gravity:   float  'Gravity in X, Y and Z direction'
DomainFluidSettings.grid_levels -> grid_levels:   int  'Number of coarsened grids to use (-1 for automatic)'
DomainFluidSettings.memory_estimate -> memory_estimate:   string,  '(read-only)    Estimated amount of memory needed for baking the domain'
DomainFluidSettings.override_time -> use_time_override:   boolean  "Use a custom start and end time (in seconds) instead of the scene's timeline"
DomainFluidSettings.partial_slip_factor -> partial_slip_factor:   float  'Amount of mixing between no- and free-slip, 0 is no slip and 1 is free slip'
DomainFluidSettings.path -> path:   string  'Directory (and/or filename prefix) to store baked fluid simulation files in'
DomainFluidSettings.preview_resolution -> preview_resolution:   int  'Preview resolution in X,Y and Z direction'
DomainFluidSettings.real_world_size -> real_world_size:   float  'Size of the simulation domain in metres'
DomainFluidSettings.render_display_mode -> render_display_mode:   enum  'How to display the mesh for rendering'
DomainFluidSettings.resolution -> resolution:   int  'Domain resolution in X,Y and Z direction'
DomainFluidSettings.reverse_frames -> use_reverse_frames:   boolean  'Reverse fluid frames'
DomainFluidSettings.slip_type -> slip_type:   enum  'NO DESCRIPTION'
DomainFluidSettings.start_time -> start_time:   float  'Simulation time of the first blender frame'
DomainFluidSettings.surface_smoothing -> surface_smooth:   float  'Amount of surface smoothing. A value of 0 is off, 1 is normal smoothing and more than 1 is extra smoothing'
DomainFluidSettings.surface_subdivisions -> surface_subdivisions:   int  'Number of isosurface subdivisions. This is necessary for the inclusion of particles into the surface generation. Warning - can lead to longer computation times!'
DomainFluidSettings.tracer_particles -> tracer_particles:   int  'Number of tracer particles to generate'
DomainFluidSettings.viewport_display_mode -> viewport_display_mode:   enum  'How to display the mesh in the viewport'
DomainFluidSettings.viscosity_base -> viscosity_base:   float  'Viscosity setting: value that is multiplied by 10 to the power of (exponent*-1)'
DomainFluidSettings.viscosity_exponent -> viscosity_exponent:   int  'Negative exponent for the viscosity value (to simplify entering small values e.g. 5*10^-6.)'
DomainFluidSettings.viscosity_preset -> viscosity_preset:   enum  'Set viscosity of the fluid to a preset value, or use manual input'
NEGATE * DopeSheet.collapse_summary -> show_expanded_summary:   boolean  'Collapse summary when shown, so all other channels get hidden. (DopeSheet Editors Only)'
DopeSheet.display_armature -> show_armatures:   boolean  'Include visualization of Armature related Animation data'
DopeSheet.display_camera -> show_cameras:   boolean  'Include visualization of Camera related Animation data'
DopeSheet.display_curve -> show_curves:   boolean  'Include visualization of Curve related Animation data'
DopeSheet.display_hidden -> display_hidden:   boolean  "Include channels from objects/bone that aren't visible"
DopeSheet.display_lamp -> show_lamps:   boolean  'Include visualization of Lamp related Animation data'
DopeSheet.display_material -> show_materials:   boolean  'Include visualization of Material related Animation data'
DopeSheet.display_mesh -> show_meshes:   boolean  'Include visualization of Mesh related Animation data'
DopeSheet.display_metaball -> show_metaballs:   boolean  'Include visualization of Metaball related Animation data'
DopeSheet.display_node -> show_nodes:   boolean  'Include visualization of Node related Animation data'
DopeSheet.display_particle -> show_particles:   boolean  'Include visualization of Particle related Animation data'
DopeSheet.display_scene -> show_scenes:   boolean  'Include visualization of Scene related Animation data'
DopeSheet.display_shapekeys -> show_shapekeys:   boolean  'Include visualization of ShapeKey related Animation data'
DopeSheet.display_summary -> show_summary:   boolean  "Display an additional 'summary' line. (DopeSheet Editors only)"
DopeSheet.display_texture -> show_textures:   boolean  'Include visualization of Texture related Animation data'
DopeSheet.display_transforms -> show_transforms:   boolean  'Include visualization of Object-level Animation data (mostly Transforms)'
DopeSheet.display_world -> show_worlds:   boolean  'Include visualization of World related Animation data'
DopeSheet.filtering_group -> filtering_group:   pointer  'Group that included Object should be a member of'
DopeSheet.include_missing_nla -> show_missing_nla:   boolean  'Include Animation Data blocks with no NLA data. (NLA Editor only)'
DopeSheet.only_group_objects -> show_only_group_objects:   boolean  'Only include channels from Objects in the specified Group'
DopeSheet.only_selected -> show_only_selected:   boolean  'Only include channels relating to selected objects and data'
DopeSheet.source -> source:   pointer,  '(read-only)    ID-Block representing source data, currently ID_SCE (for Dopesheet), and ID_SC (for Grease Pencil)'
Driver.expression -> expression:   string  'Expression to use for Scripted Expression'
Driver.invalid -> is_valid:   boolean  'Driver could not be evaluated in past, so should be skipped'
Driver.show_debug_info -> show_debug_info:   boolean  'Show intermediate values for the driver calculations to allow debugging of drivers'
Driver.type -> type:   enum  'Driver type'
Driver.variables -> variables:   collection,  '(read-only)    Properties acting as inputs for this driver'
DriverTarget.bone_target -> bone_target:   string  'Name of PoseBone to use as target'
DriverTarget.data_path -> data_path:   string  'RNA Path (from ID-block) to property used'
DriverTarget.id -> id:   pointer  'ID-block that the specific property used can be found from (id_type property must be set first)'
DriverTarget.id_type -> id_type:   enum  'Type of ID-block that can be used'
DriverTarget.transform_type -> transform_type:   enum  'Driver variable type'
DriverTarget.use_local_space_transforms -> use_local_space_transform:   boolean  'Use transforms in Local Space (as opposed to the worldspace default)'
DriverVariable.name -> name:   string  'Name to use in scripted expressions/functions. (No spaces or dots are allowed. Also, must not start with a symbol or digit)'
DriverVariable.targets -> targets:   collection,  '(read-only)    Sources of input data for evaluating this variable'
DriverVariable.type -> type:   enum  'Driver variable type'
DupliObject.matrix -> matrix:   float  'Object duplicate transformation matrix'
DupliObject.object -> object:   pointer,  '(read-only)    Object being duplicated'
DupliObject.object_matrix -> object_matrix:   float  'Duplicated object transformation matrix'
EdgeSplitModifier.split_angle -> split_angle:   float  'Angle above which to split edges'
EdgeSplitModifier.use_edge_angle -> use_edge_angle:   boolean  'Split edges with high angle between faces'
EdgeSplitModifier.use_sharp -> use_edge_sharp:   boolean  'Split edges that are marked as sharp'
EditBone.bbone_in -> bbone_in:   float  'Length of first Bezier Handle (for B-Bones only)'
EditBone.bbone_out -> bbone_out:   float  'Length of second Bezier Handle (for B-Bones only)'
EditBone.bbone_segments -> bbone_segments:   int  'Number of subdivisions of bone (for B-Bones only)'
EditBone.connected -> use_connect:   boolean  "When bone has a parent, bone's head is struck to the parent's tail"
EditBone.cyclic_offset -> use_cyclic_offset:   boolean  "When bone doesn't have a parent, it receives cyclic offset effects"
EditBone.deform -> use_deform:   boolean  'Bone does not deform any geometry'
EditBone.draw_wire -> show_wire:   boolean  'Bone is always drawn as Wireframe regardless of viewport draw mode. Useful for non-obstructive custom bone shapes'
EditBone.envelope_distance -> envelope_distance:   float  'Bone deformation distance (for Envelope deform only)'
EditBone.envelope_weight -> envelope_weight:   float  'Bone deformation weight (for Envelope deform only)'
EditBone.head -> head:   float  'Location of head end of the bone'
EditBone.head_radius -> head_radius:   float  'Radius of head of bone (for Envelope deform only)'
EditBone.hide -> hide:   boolean  'Bone is not visible when in Edit Mode'
EditBone.hide_select -> hide_select:   boolean  'Bone is able to be selected'
EditBone.hinge -> use_hinge:   boolean  'Bone inherits rotation or scale from parent bone'
EditBone.inherit_scale -> use_inherit_scale:   boolean  'Bone inherits scaling from parent bone'
EditBone.layer -> layers:   boolean  'Layers bone exists in'
EditBone.local_location -> use_local_location:   boolean  'Bone location is set in local space'
EditBone.lock -> lock:   boolean  'Bone is not able to be transformed when in Edit Mode'
EditBone.matrix -> matrix:   float,  '(read-only)    Read-only matrix calculated from the roll (armature space)'
EditBone.multiply_vertexgroup_with_envelope -> use_envelope_multiply:   boolean  'When deforming bone, multiply effects of Vertex Group weights with Envelope influence'
EditBone.name -> name:   string  'NO DESCRIPTION'
EditBone.parent -> parent:   pointer  'Parent edit bone (in same Armature)'
EditBone.roll -> roll:   float  'Bone rotation around head-tail axis'
EditBone.select -> select:   boolean  'NO DESCRIPTION'
EditBone.select_head -> select_head:   boolean  'NO DESCRIPTION'
EditBone.select_tail -> select_tail:   boolean  'NO DESCRIPTION'
EditBone.tail -> tail:   float  'Location of tail end of the bone'
EditBone.tail_radius -> tail_radius:   float  'Radius of tail of bone (for Envelope deform only)'
EditObjectActuator.angular_velocity -> angular_velocity:   float  'Angular velocity upon creation'
EditObjectActuator.dynamic_operation -> dynamic_operation:   enum  'NO DESCRIPTION'
EditObjectActuator.enable_3d_tracking -> use_3d_tracking:   boolean  'Enable 3D tracking'
EditObjectActuator.linear_velocity -> linear_velocity:   float  'Velocity upon creation'
EditObjectActuator.local_angular_velocity -> use_local_angular_velocity:   boolean  'Apply the rotation locally'
EditObjectActuator.local_linear_velocity -> use_local_linear_velocity:   boolean  'Apply the transformation locally'
EditObjectActuator.mass -> mass:   float  'The mass of the object'
EditObjectActuator.mesh -> mesh:   pointer  "Replace the existing, when left blank 'Phys' will remake the existing physics mesh"
EditObjectActuator.mode -> mode:   enum  'The mode of the actuator'
EditObjectActuator.object -> object:   pointer  'Add this Object and all its children (cant be on an visible layer)'
EditObjectActuator.replace_display_mesh -> use_replace_display_mesh:   boolean  'Replace the display mesh'
EditObjectActuator.replace_physics_mesh -> use_replace_physics_mesh:   boolean  'Replace the physics mesh (triangle bounds only - compound shapes not supported)'
EditObjectActuator.time -> time:   int  'Duration the new Object lives or the track takes'
EditObjectActuator.track_object -> track_object:   pointer  'Track to this Object'
EffectSequence.color_balance -> color_balance:   pointer,  '(read-only)'
EffectSequence.color_saturation -> color_saturation:   float  'NO DESCRIPTION'
EffectSequence.convert_float -> use_float:   boolean  'Convert input to float data'
EffectSequence.crop -> crop:   pointer,  '(read-only)'
EffectSequence.de_interlace -> use_deinterlace:   boolean  'For video movies to remove fields'
EffectSequence.flip_x -> use_flip_x:   boolean  'Flip on the X axis'
EffectSequence.flip_y -> use_flip_y:   boolean  'Flip on the Y axis'
EffectSequence.multiply_colors -> color_multiply:   float  'NO DESCRIPTION'
EffectSequence.premultiply -> use_premultiply:   boolean  'Convert RGB from key alpha to premultiplied alpha'
EffectSequence.proxy -> proxy:   pointer,  '(read-only)'
EffectSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  'Use a custom directory to store data'
EffectSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  'Use a custom file to read proxy data from'
EffectSequence.reverse_frames -> use_reverse_frames:   boolean  'Reverse frame order'
EffectSequence.strobe -> strobe:   float  'Only display every nth frame'
EffectSequence.transform -> transform:   pointer,  '(read-only)'
EffectSequence.use_color_balance -> use_color_balance:   boolean  '(3-Way color correction) on input'
EffectSequence.use_crop -> use_crop:   boolean  'Crop image before processing'
EffectSequence.use_proxy -> use_proxy:   boolean  'Use a preview proxy for this strip'
EffectSequence.use_translation -> use_translation:   boolean  'Translate image before processing'
EffectorWeights.all -> all:   float  "All effector's weight"
EffectorWeights.boid -> boid:   float  'Boid effector weight'
EffectorWeights.charge -> charge:   float  'Charge effector weight'
EffectorWeights.curveguide -> curveguide:   float  'Curve guide effector weight'
EffectorWeights.do_growing_hair -> apply_to_hair_growing:   boolean  'Use force fields when growing hair'
EffectorWeights.drag -> drag:   float  'Drag effector weight'
EffectorWeights.force -> force:   float  'Force effector weight'
EffectorWeights.gravity -> gravity:   float  'Global gravity weight'
EffectorWeights.group -> group:   pointer  'Limit effectors to this Group'
EffectorWeights.harmonic -> harmonic:   float  'Harmonic effector weight'
EffectorWeights.lennardjones -> lennardjones:   float  'Lennard-Jones effector weight'
EffectorWeights.magnetic -> magnetic:   float  'Magnetic effector weight'
EffectorWeights.texture -> texture:   float  'Texture effector weight'
EffectorWeights.turbulence -> turbulence:   float  'Turbulence effector weight'
EffectorWeights.vortex -> vortex:   float  'Vortex effector weight'
EffectorWeights.wind -> wind:   float  'Wind effector weight'
EnumProperty.default -> default:   enum,  '(read-only)    Default value for this enum'
EnumProperty.items -> items:   collection,  '(read-only)    Possible values for the property'
EnumPropertyItem.description -> description:   string,  "(read-only)    Description of the item's purpose"
EnumPropertyItem.identifier -> identifier:   string,  '(read-only)    Unique name used in the code and scripting'
EnumPropertyItem.name -> name:   string,  '(read-only)    Human readable name'
EnumPropertyItem.value -> value:   int,  '(read-only)    Value of the item'
EnvironmentMap.clip_end -> clip_end:   float  'Objects further than this are not visible to map'
EnvironmentMap.clip_start -> clip_start:   float  'Objects nearer than this are not visible to map'
EnvironmentMap.depth -> depth:   int  'Number of times a map will be rendered recursively (mirror effects.)'
EnvironmentMap.ignore_layers -> layers_ignore:   boolean  'Hide objects on these layers when generating the Environment Map'
EnvironmentMap.mapping -> mapping:   enum  'NO DESCRIPTION'
EnvironmentMap.resolution -> resolution:   int  'Pixel resolution of the rendered environment map'
EnvironmentMap.source -> source:   enum  'NO DESCRIPTION'
EnvironmentMap.viewpoint_object -> viewpoint_object:   pointer  "Object to use as the environment map's viewpoint location"
EnvironmentMap.zoom -> zoom:   float  'NO DESCRIPTION'
EnvironmentMapTexture.environment_map -> environment_map:   pointer,  '(read-only)    Gets the environment map associated with this texture'
EnvironmentMapTexture.filter -> filter:   enum  'Texture filter to use for sampling image'
EnvironmentMapTexture.filter_eccentricity -> filter_eccentricity:   int  'Maximum eccentricity. Higher gives less blur at distant/oblique angles, but is also slower'
EnvironmentMapTexture.filter_probes -> filter_probes:   int  'Maximum number of samples. Higher gives less blur at distant/oblique angles, but is also slower'
EnvironmentMapTexture.filter_size -> filter_size:   float  'Multiplies the filter size used by MIP Map and Interpolation'
EnvironmentMapTexture.filter_size_minimum -> use_filter_size_min:   boolean  'Use Filter Size as a minimal filter value in pixels'
EnvironmentMapTexture.image -> image:   pointer  'Source image file to read the environment map from'
EnvironmentMapTexture.image_user -> image_user:   pointer,  '(read-only)    Parameters defining which layer, pass and frame of the image is displayed'
EnvironmentMapTexture.mipmap -> use_mipmap:   boolean  'Uses auto-generated MIP maps for the image'
EnvironmentMapTexture.mipmap_gauss -> use_mipmap_gauss:   boolean  'Uses Gauss filter to sample down MIP maps'
Event.alt -> is_pressed_alt:   boolean,  '(read-only)    True when the Alt/Option key is held'
Event.ascii -> ascii:   string,  '(read-only)    Single ASCII character for this event'
Event.ctrl -> is_pressed_ctrl:   boolean,  '(read-only)    True when the Ctrl key is held'
Event.mouse_prev_x -> mouse_prev_x:   int,  '(read-only)    The window relative vertical location of the mouse'
Event.mouse_prev_y -> mouse_prev_y:   int,  '(read-only)    The window relative horizontal location of the mouse'
Event.mouse_region_x -> mouse_region_x:   int,  '(read-only)    The region relative vertical location of the mouse'
Event.mouse_region_y -> mouse_region_y:   int,  '(read-only)    The region relative horizontal location of the mouse'
Event.mouse_x -> mouse_x:   int,  '(read-only)    The window relative vertical location of the mouse'
Event.mouse_y -> mouse_y:   int,  '(read-only)    The window relative horizontal location of the mouse'
Event.oskey -> is_pressed_cmd:   boolean,  '(read-only)    True when the Cmd key is held'
Event.shift -> is_pressed_shift:   boolean,  '(read-only)    True when the Shift key is held'
Event.type -> type:   enum,  '(read-only)'
Event.value -> value:   enum,  '(read-only)    The type of event, only applies to some'
ExplodeModifier.alive -> show_alive:   boolean  'Show mesh when particles are alive'
ExplodeModifier.dead -> show_dead:   boolean  'Show mesh when particles are dead'
ExplodeModifier.protect -> protect:   float  'Clean vertex group edges'
ExplodeModifier.size -> use_size:   boolean  'Use particle size for the shrapnel'
ExplodeModifier.split_edges -> use_edge_split:   boolean  'Split face edges for nicer shrapnel'
ExplodeModifier.unborn -> show_unborn:   boolean  'Show mesh when particles are unborn'
ExplodeModifier.vertex_group -> vertex_group:   string  'NO DESCRIPTION'
ExpressionController.expression -> expression:   string  'NO DESCRIPTION'
FCurve.array_index -> array_index:   int  'Index to the specific property affected by F-Curve if applicable'
FCurve.auto_clamped_handles -> use_auto_handle_clamp:   boolean  'All auto-handles for F-Curve are clamped'
FCurve.color -> color:   float  'Color of the F-Curve in the Graph Editor'
FCurve.color_mode -> color_mode:   enum  'Method used to determine color of F-Curve in Graph Editor'
FCurve.data_path -> data_path:   string  'RNA Path to property affected by F-Curve'
FCurve.driver -> driver:   pointer,  '(read-only)    Channel Driver (only set for Driver F-Curves)'
FCurve.enabled -> enabled:   boolean  'False when F-Curve could not be evaluated in past, so should be skipped when evaluating'
FCurve.extrapolation -> extrapolation:   enum  'NO DESCRIPTION'
FCurve.group -> group:   pointer  'Action Group that this F-Curve belongs to'
FCurve.hide -> hide:   boolean  'F-Curve and its keyframes are hidden in the Graph Editor graphs'
FCurve.keyframe_points -> keyframe_points:   collection,  '(read-only)    User-editable keyframes'
FCurve.lock -> lock:   boolean  "F-Curve's settings cannot be edited"
FCurve.modifiers -> modifiers:   collection,  '(read-only)    Modifiers affecting the shape of the F-Curve'
FCurve.mute -> mute:   boolean  'F-Curve is not evaluated'
FCurve.sampled_points -> sampled_points:   collection,  '(read-only)    Sampled animation data'
FCurve.select -> select:   boolean  'F-Curve is selected for editing'
FCurveModifiers.active -> active:   pointer  'Active F-Curve Modifier'
FCurveSample.co -> co:   float  'Point coordinates'
FCurveSample.select -> select:   boolean  'Selection status'
FModifier.active -> active:   boolean  'F-Curve Modifier is the one being edited'
NEGATE * FModifier.disabled -> use:   boolean,  '(read-only)    F-Curve Modifier has invalid settings and will not be evaluated'
FModifier.expanded -> show_expanded:   boolean  "F-Curve Modifier's panel is expanded in UI"
FModifier.mute -> mute:   boolean  'F-Curve Modifier will not be evaluated'
FModifier.type -> type:   enum,  '(read-only)    F-Curve Modifier Type'
FModifierCycles.after_cycles -> after_cycles:   float  'Maximum number of cycles to allow after last keyframe. (0 = infinite)'
FModifierCycles.after_mode -> after_mode:   enum  'Cycling mode to use after last keyframe'
FModifierCycles.before_cycles -> before_cycles:   float  'Maximum number of cycles to allow before first keyframe. (0 = infinite)'
FModifierCycles.before_mode -> before_mode:   enum  'Cycling mode to use before first keyframe'
FModifierEnvelope.control_points -> control_points:   collection,  '(read-only)    Control points defining the shape of the envelope'
FModifierEnvelope.default_maximum -> default_max:   float  'Upper distance from Reference Value for 1:1 default influence'
FModifierEnvelope.default_minimum -> default_min:   float  'Lower distance from Reference Value for 1:1 default influence'
FModifierEnvelope.reference_value -> reference_value:   float  "Value that envelope's influence is centered around / based on"
FModifierEnvelopeControlPoint.frame -> frame:   float  'Frame this control-point occurs on'
FModifierEnvelopeControlPoint.maximum -> max:   float  'Upper bound of envelope at this control-point'
FModifierEnvelopeControlPoint.minimum -> min:   float  'Lower bound of envelope at this control-point'
FModifierFunctionGenerator.additive -> use_additive:   boolean  'Values generated by this modifier are applied on top of the existing values instead of overwriting them'
FModifierFunctionGenerator.amplitude -> amplitude:   float  'Scale factor determining the maximum/minimum values'
FModifierFunctionGenerator.function_type -> function_type:   enum  'Type of built-in function to use'
FModifierFunctionGenerator.phase_multiplier -> phase_multiplier:   float  "Scale factor determining the 'speed' of the function"
FModifierFunctionGenerator.phase_offset -> phase_offset:   float  'Constant factor to offset time by for function'
FModifierFunctionGenerator.value_offset -> value_offset:   float  'Constant factor to offset values by'
FModifierGenerator.additive -> use_additive:   boolean  'Values generated by this modifier are applied on top of the existing values instead of overwriting them'
FModifierGenerator.coefficients -> coefficients:   float  "Coefficients for 'x' (starting from lowest power of x^0)"
FModifierGenerator.mode -> mode:   enum  'Type of generator to use'
FModifierGenerator.poly_order -> poly_order:   int  "The highest power of 'x' for this polynomial. (number of coefficients - 1)"
FModifierLimits.maximum_x -> max_x:   float  'Highest X value to allow'
FModifierLimits.maximum_y -> max_y:   float  'Highest Y value to allow'
FModifierLimits.minimum_x -> min_x:   float  'Lowest X value to allow'
FModifierLimits.minimum_y -> min_y:   float  'Lowest Y value to allow'
FModifierLimits.use_maximum_x -> use_max_x:   boolean  'Use the maximum X value'
FModifierLimits.use_maximum_y -> use_max_y:   boolean  'Use the maximum Y value'
FModifierLimits.use_minimum_x -> use_min_x:   boolean  'Use the minimum X value'
FModifierLimits.use_minimum_y -> use_min_y:   boolean  'Use the minimum Y value'
FModifierNoise.depth -> depth:   int  'Amount of fine level detail present in the noise'
FModifierNoise.modification -> modification:   enum  'Method of modifying the existing F-Curve'
FModifierNoise.phase -> phase:   float  'A random seed for the noise effect'
FModifierNoise.size -> size:   float  'Scaling (in time) of the noise'
FModifierNoise.strength -> strength:   float  'Amplitude of the noise - the amount that it modifies the underlying curve'
FModifierStepped.frame_end -> frame_end:   float  "Frame that modifier's influence ends (if applicable)"
FModifierStepped.frame_start -> frame_start:   float  "Frame that modifier's influence starts (if applicable)"
FModifierStepped.offset -> offset:   float  "Reference number of frames before frames get held. Use to get hold for '1-3' vs '5-7' holding patterns"
FModifierStepped.step_size -> step_size:   float  'Number of frames to hold each value'
FModifierStepped.use_frame_end -> use_frame_end:   boolean  "Restrict modifier to only act before its 'end' frame"
FModifierStepped.use_frame_start -> use_frame_start:   boolean  "Restrict modifier to only act after its 'start' frame"
FcurveActuator.add -> use_add:   boolean  'F-Curve is added to the current loc/rot/scale in global or local coordinate according to Local flag'
FcurveActuator.child -> apply_to_children:   boolean  'Update F-Curve on all children Objects as well'
FcurveActuator.force -> use_force:   boolean  'Apply F-Curve as a global or local force depending on the local option (dynamic objects only)'
FcurveActuator.frame_end -> frame_end:   int  'NO DESCRIPTION'
FcurveActuator.frame_property -> frame_property:   string  "Assign the action's current frame number to this property"
FcurveActuator.frame_start -> frame_start:   int  'NO DESCRIPTION'
FcurveActuator.local -> use_local:   boolean  'Let the F-Curve act in local coordinates, used in Force and Add mode'
FcurveActuator.play_type -> play_type:   enum  'Specify the way you want to play the animation'
FcurveActuator.property -> property:   string  'Use this property to define the F-Curve position'
FieldSettings.do_absorption -> use_absorption:   boolean  'Force gets absorbed by collision objects'
FieldSettings.do_location -> apply_to_location:   boolean  "Effect particles' location"
FieldSettings.do_rotation -> apply_to_rotation:   boolean  "Effect particles' dynamic rotation"
FieldSettings.falloff_power -> falloff_power:   float  'Falloff power (real gravitational falloff = 2)'
FieldSettings.falloff_type -> falloff_type:   enum  'Fall-off shape'
FieldSettings.flow -> flow:   float  'Convert effector force into air flow velocity'
FieldSettings.force_2d -> use_2d_force:   boolean  'Apply force only in 2d'
FieldSettings.global_coordinates -> use_global_coordinates:   boolean  'Use effector/global coordinates for turbulence'
FieldSettings.guide_clump_amount -> guide_clump_amount:   float  'Amount of clumping'
FieldSettings.guide_clump_shape -> guide_clump_shape:   float  'Shape of clumping'
FieldSettings.guide_free -> guide_free:   float  "Guide-free time from particle life's end"
FieldSettings.guide_kink_amplitude -> guide_kink_amplitude:   float  'The amplitude of the offset'
FieldSettings.guide_kink_axis -> guide_kink_axis:   enum  'Which axis to use for offset'
FieldSettings.guide_kink_frequency -> guide_kink_frequency:   float  'The frequency of the offset (1/total length)'
FieldSettings.guide_kink_shape -> guide_kink_shape:   float  'Adjust the offset to the beginning/end'
FieldSettings.guide_kink_type -> guide_kink_type:   enum  'Type of periodic offset on the curve'
FieldSettings.guide_minimum -> guide_minimum:   float  'The distance from which particles are affected fully'
FieldSettings.guide_path_add -> use_guide_path_add:   boolean  'Based on distance/falloff it adds a portion of the entire path'
FieldSettings.harmonic_damping -> harmonic_damping:   float  'Damping of the harmonic force'
FieldSettings.inflow -> inflow:   float  'Inwards component of the vortex force'
FieldSettings.linear_drag -> linear_drag:   float  'Drag component proportional to velocity'
FieldSettings.maximum_distance -> distance_max:   float  'Maximum distance for the field to work'
FieldSettings.minimum_distance -> distance_min:   float  "Minimum distance for the field's fall-off"
FieldSettings.multiple_springs -> use_multiple_springs:   boolean  'Every point is effected by multiple springs'
FieldSettings.noise -> noise:   float  'Noise of the force'
FieldSettings.quadratic_drag -> quadratic_drag:   float  'Drag component proportional to the square of velocity'
FieldSettings.radial_falloff -> radial_falloff:   float  'Radial falloff power (real gravitational falloff = 2)'
FieldSettings.radial_maximum -> radial_max:   float  'Maximum radial distance for the field to work'
FieldSettings.radial_minimum -> radial_min:   float  "Minimum radial distance for the field's fall-off"
FieldSettings.rest_length -> rest_length:   float  'Rest length of the harmonic force'
FieldSettings.root_coordinates -> use_root_coordinates:   boolean  'Texture coordinates from root particle locations'
FieldSettings.seed -> seed:   int  'Seed of the noise'
FieldSettings.shape -> shape:   enum  'Which direction is used to calculate the effector force'
FieldSettings.size -> size:   float  'Size of the noise'
FieldSettings.strength -> strength:   float  'Strength of force field'
FieldSettings.texture -> texture:   pointer  'Texture to use as force'
FieldSettings.texture_mode -> texture_mode:   enum  'How the texture effect is calculated (RGB & Curl need a RGB texture else Gradient will be used instead)'
FieldSettings.texture_nabla -> texture_nabla:   float  'Defines size of derivative offset used for calculating gradient and curl'
FieldSettings.type -> type:   enum  'Type of field'
FieldSettings.use_coordinates -> use_object_coordinates:   boolean  'Use object/global coordinates for texture'
FieldSettings.use_guide_path_weight -> use_guide_path_weight:   boolean  'Use curve weights to influence the particle influence along the curve'
FieldSettings.use_max_distance -> use_max_distance:   boolean  'Use a maximum distance for the field to work'
FieldSettings.use_min_distance -> use_min_distance:   boolean  "Use a minimum distance for the field's fall-off"
FieldSettings.use_radial_max -> use_radial_max:   boolean  'Use a maximum radial distance for the field to work'
FieldSettings.use_radial_min -> use_radial_min:   boolean  "Use a minimum radial distance for the field's fall-off"
FieldSettings.z_direction -> z_direction:   enum  'Effect in full or only positive/negative Z direction'
FileSelectParams.directory -> directory:   string  'Directory displayed in the file browser'
FileSelectParams.display -> display:   enum  'Display mode for the file list'
FileSelectParams.do_filter -> use_filter:   boolean  'Enable filtering of files'
FileSelectParams.file -> file:   string  'Active file in the file browser'
FileSelectParams.filter_blender -> use_filter_blender:   boolean  'Show .blend files'
FileSelectParams.filter_folder -> use_filter_folder:   boolean  'Show folders'
FileSelectParams.filter_font -> use_filter_font:   boolean  'Show font files'
FileSelectParams.filter_image -> use_filter_image:   boolean  'Show image files'
FileSelectParams.filter_movie -> use_filter_movie:   boolean  'Show movie files'
FileSelectParams.filter_script -> use_filter_script:   boolean  'Show script files'
FileSelectParams.filter_sound -> use_filter_sound:   boolean  'Show sound files'
FileSelectParams.filter_text -> use_filter_text:   boolean  'Show text files'
NEGATE * FileSelectParams.hide_dot -> show_hidden:   boolean  'Hide hidden dot files'
FileSelectParams.sort -> sort:   enum  'NO DESCRIPTION'
FileSelectParams.title -> title:   string,  '(read-only)    Title for the file browser'
Filter2DActuator.enable_motion_blur -> use_motion_blur:   boolean  'Enable/Disable Motion Blur'
Filter2DActuator.filter_pass -> filter_pass:   int  'Set filter order'
Filter2DActuator.glsl_shader -> glsl_shader:   pointer  'NO DESCRIPTION'
Filter2DActuator.mode -> mode:   enum  'NO DESCRIPTION'
Filter2DActuator.motion_blur_factor -> motion_blur_factor:   float  'Set motion blur factor'
FloatProperty.array_length -> array_length:   int,  '(read-only)    Maximum length of the array, 0 means unlimited'
FloatProperty.default -> default:   float,  '(read-only)    Default value for this number'
FloatProperty.default_array -> default_array:   float,  '(read-only)    Default value for this array'
FloatProperty.hard_max -> hard_max:   float,  '(read-only)    Maximum value used by buttons'
FloatProperty.hard_min -> hard_min:   float,  '(read-only)    Minimum value used by buttons'
FloatProperty.precision -> precision:   int,  '(read-only)    Number of digits after the dot used by buttons'
FloatProperty.soft_max -> soft_max:   float,  '(read-only)    Maximum value used by buttons'
FloatProperty.soft_min -> soft_min:   float,  '(read-only)    Minimum value used by buttons'
FloatProperty.step -> step:   float,  '(read-only)    Step size used by number buttons, for floats 1/100th of the step size'
FloorConstraint.floor_location -> floor_location:   enum  'Location of target that object will not pass through'
FloorConstraint.offset -> offset:   float  'Offset of floor from object origin'
FloorConstraint.sticky -> use_sticky:   boolean  'Immobilize object while constrained'
FloorConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
FloorConstraint.target -> target:   pointer  'Target Object'
FloorConstraint.use_rotation -> use_rotation:   boolean  "Use the target's rotation to determine floor"
FluidFluidSettings.active -> use:   boolean  'Object contributes to the fluid simulation'
FluidFluidSettings.export_animated_mesh -> use_animated_mesh:   boolean  'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'
FluidFluidSettings.initial_velocity -> initial_velocity:   float  'Initial velocity of fluid'
FluidFluidSettings.volume_initialization -> volume_initialization:   enum  'Volume initialization type'
FluidSettings.type -> type:   enum  'Type of participation in the fluid simulation'
FluidSimulationModifier.settings -> settings:   pointer,  '(read-only)    Settings for how this object is used in the fluid simulation'
FollowPathConstraint.forward -> forward:   enum  'Axis that points forward along the path'
FollowPathConstraint.offset -> offset:   int  'Offset from the position corresponding to the time frame'
FollowPathConstraint.offset_factor -> offset_factor:   float  'Percentage value defining target position along length of bone'
FollowPathConstraint.target -> target:   pointer  'Target Object'
FollowPathConstraint.up -> up:   enum  'Axis that points upward'
FollowPathConstraint.use_curve_follow -> use_curve_follow:   boolean  'Object will follow the heading and banking of the curve'
FollowPathConstraint.use_curve_radius -> use_curve_radius:   boolean  'Objects scale by the curve radius'
FollowPathConstraint.use_fixed_position -> use_fixed_location:   boolean  'Object will stay locked to a single point somewhere along the length of the curve regardless of time'
Function.description -> description:   string,  "(read-only)    Description of the Function's purpose"
Function.identifier -> identifier:   string,  '(read-only)    Unique name used in the code and scripting'
Function.parameters -> parameters:   collection,  '(read-only)    Parameters for the function'
Function.registered -> is_registered:   boolean,  '(read-only)    Function is registered as callback as part of type registration'
Function.registered_optional -> is_registered_optional:   boolean,  '(read-only)    Function is optionally registered as callback part of type registration'
GPencilFrame.frame_number -> frame_number:   int  'The frame on which this sketch appears'
GPencilFrame.paint_lock -> is_edited:   boolean  'Frame is being edited (painted on)'
GPencilFrame.select -> select:   boolean  'Frame is selected for editing in the DopeSheet'
GPencilFrame.strokes -> strokes:   collection,  '(read-only)    Freehand curves defining the sketch on this frame'
GPencilLayer.active -> active:   boolean  'Set active layer for editing'
GPencilLayer.active_frame -> active_frame:   pointer,  '(read-only)    Frame currently being displayed for this layer'
GPencilLayer.color -> color:   float  'Color for all strokes in this layer'
GPencilLayer.frame_lock -> lock_frame:   boolean  'Lock current frame displayed by layer'
GPencilLayer.frames -> frames:   collection,  '(read-only)    Sketches for this layer on different frames'
GPencilLayer.hide -> hide:   boolean  'Set layer Visibility'
GPencilLayer.info -> info:   string  'Layer name'
GPencilLayer.line_thickness -> line_width:   int  'Thickness of strokes (in pixels)'
GPencilLayer.lock -> lock:   boolean  'Protect layer from further editing and/or frame changes'
GPencilLayer.max_ghost_range -> ghost_range_max:   int  "Maximum number of frames on either side of the active frame to show (0 = show the 'first' available sketch on either side)"
GPencilLayer.opacity -> opacity:   float  'Layer Opacity'
GPencilLayer.select -> select:   boolean  'Layer is selected for editing in the DopeSheet'
GPencilLayer.show_points -> show_points:   boolean  'Draw the points which make up the strokes (for debugging purposes)'
GPencilLayer.use_onion_skinning -> use_onion_skinning:   boolean  'Ghost frames on either side of frame'
GPencilStroke.points -> points:   collection,  '(read-only)    Stroke data points'
GPencilStrokePoint.co -> co:   float  'NO DESCRIPTION'
GPencilStrokePoint.pressure -> pressure:   float  'Pressure of tablet at point when drawing it'
GameActuator.filename -> filename:   string  'Load this blend file, use the "//" prefix for a path relative to the current blend file'
GameActuator.mode -> mode:   enum  'NO DESCRIPTION'
GameBooleanProperty.value -> value:   boolean  'Property value'
GameFloatProperty.value -> value:   float  'Property value'
GameIntProperty.value -> value:   int  'Property value'
GameObjectSettings.actor -> use_actor:   boolean  'Object is detected by the Near and Radar sensor'
GameObjectSettings.actuators -> actuators:   collection,  '(read-only)    Game engine actuators to act on events'
GameObjectSettings.all_states -> use_all_states:   boolean  'Set all state bits'
GameObjectSettings.anisotropic_friction -> use_anisotropic_friction:   boolean  'Enable anisotropic friction'
GameObjectSettings.collision_bounds -> collision_bounds:   enum  'Selects the collision type'
GameObjectSettings.collision_compound -> use_collision_compound:   boolean  'Add children to form a compound collision object'
GameObjectSettings.collision_margin -> collision_margin:   float  'Extra margin around object for collision detection, small amount required for stability'
GameObjectSettings.controllers -> controllers:   collection,  '(read-only)    Game engine controllers to process events, connecting sensor to actuators'
GameObjectSettings.damping -> damping:   float  'General movement damping'
GameObjectSettings.debug_state -> show_debug_state:   boolean  'Print state debug info in the game engine'
GameObjectSettings.form_factor -> form_factor:   float  'Form factor scales the inertia tensor'
GameObjectSettings.friction_coefficients -> friction_coefficients:   float  'Relative friction coefficient in the in the X, Y and Z directions, when anisotropic friction is enabled'
GameObjectSettings.ghost -> use_ghost:   boolean  'Object does not restitute collisions, like a ghost'
GameObjectSettings.initial_state -> states_initial:   boolean  'Initial state when the game starts'
GameObjectSettings.lock_x_axis -> lock_location_x:   boolean  'Disable simulation of linear motion along the X axis'
GameObjectSettings.lock_x_rot_axis -> lock_rotation_x:   boolean  'Disable simulation of angular  motion along the X axis'
GameObjectSettings.lock_y_axis -> lock_location_y:   boolean  'Disable simulation of linear motion along the Y axis'
GameObjectSettings.lock_y_rot_axis -> lock_rotation_y:   boolean  'Disable simulation of angular  motion along the Y axis'
GameObjectSettings.lock_z_axis -> lock_location_z:   boolean  'Disable simulation of linear motion along the Z axis'
GameObjectSettings.lock_z_rot_axis -> lock_rotation_z:   boolean  'Disable simulation of angular  motion along the Z axis'
GameObjectSettings.mass -> mass:   float  'Mass of the object'
GameObjectSettings.material_physics -> use_material_physics:   boolean  'Use physics settings in materials'
GameObjectSettings.maximum_velocity -> velocity_max:   float  'Clamp velocity to this maximum speed'
GameObjectSettings.minimum_velocity -> velocity_min:   float  'Clamp velocity to this minimum speed (except when totally still)'
NEGATE * GameObjectSettings.no_sleeping -> use_sleep:   boolean  'Disable auto (de)activation in physics simulation'
GameObjectSettings.physics_type -> physics_type:   enum  'Selects the type of physical representation'
GameObjectSettings.properties -> properties:   collection,  '(read-only)    Game engine properties'
GameObjectSettings.radius -> radius:   float  'Radius of bounding sphere and material physics'
GameObjectSettings.rotate_from_normal -> use_rotate_from_normal:   boolean  'Use face normal to rotate object, so that it points away from the surface'
GameObjectSettings.rotation_damping -> rotation_damping:   float  'General rotation damping'
GameObjectSettings.sensors -> sensors:   collection,  '(read-only)    Game engine sensor to detect events'
GameObjectSettings.show_actuators -> show_actuators:   boolean  'Shows actuators for this object in the user interface'
GameObjectSettings.show_controllers -> show_controllers:   boolean  'Shows controllers for this object in the user interface'
GameObjectSettings.show_sensors -> show_sensors:   boolean  'Shows sensors for this object in the user interface'
GameObjectSettings.show_state_panel -> show_state_panel:   boolean  'Show state panel'
GameObjectSettings.soft_body -> soft_body:   pointer,  '(read-only)    Settings for Bullet soft body simulation'
GameObjectSettings.use_activity_culling -> use_activity_culling:   boolean  'Disable simulation of angular  motion along the Z axis'
GameObjectSettings.use_collision_bounds -> use_collision_bounds:   boolean  'Specify a collision bounds type other than the default'
GameObjectSettings.used_state -> states_used:   boolean,  '(read-only)    States which are being used by controllers'
GameObjectSettings.visible_state -> states_visible:   boolean  'State determining which controllers are displayed'
GameProperty.debug -> show_debug:   boolean  'Print debug information for this property'
GameProperty.name -> name:   string  "Available as GameObject attributes in the game engine's python API"
GameProperty.type -> type:   enum  'NO DESCRIPTION'
GameSoftBodySettings.bending_const -> use_bending_constraints:   boolean  'Enable bending constraints'
GameSoftBodySettings.cluster_iterations -> cluster_iterations:   int  'Specify the number of cluster iterations'
GameSoftBodySettings.cluster_rigid_to_softbody -> use_cluster_rigid_to_softbody:   boolean  'Enable cluster collision between soft and rigid body'
GameSoftBodySettings.cluster_soft_to_softbody -> use_cluster_soft_to_softbody:   boolean  'Enable cluster collision between soft and soft body'
GameSoftBodySettings.dynamic_friction -> dynamic_friction:   float  'Dynamic Friction'
GameSoftBodySettings.linstiff -> linear_stiffness:   float  'Linear stiffness of the soft body links'
GameSoftBodySettings.margin -> margin:   float  'Collision margin for soft body. Small value makes the algorithm unstable'
GameSoftBodySettings.position_iterations -> position_iterations:   int  'Position solver iterations'
GameSoftBodySettings.shape_match -> use_shape_match:   boolean  'Enable soft body shape matching goal'
GameSoftBodySettings.threshold -> threshold:   float  'Shape matching threshold'
GameSoftBodySettings.welding -> weld_threshold:   float  'Welding threshold: distance between nearby vertices to be considered equal => set to 0.0 to disable welding test and speed up scene loading (ok if the mesh has no duplicates)'
GameStringProperty.value -> value:   string  'Property value'
GameTimerProperty.value -> value:   float  'Property value'
GlowSequence.blur_distance -> blur_distance:   float  'Radius of glow effect'
GlowSequence.boost_factor -> boost_factor:   float  'Brightness multiplier'
GlowSequence.clamp -> clamp:   float  'rightness limit of intensity'
GlowSequence.only_boost -> use_only_boost:   boolean  'Show the glow buffer only'
GlowSequence.quality -> quality:   int  'Accuracy of the blur effect'
GlowSequence.threshold -> threshold:   float  'Minimum intensity to trigger a glow'
GreasePencil.draw_mode -> draw_mode:   enum  'NO DESCRIPTION'
GreasePencil.layers -> layers:   collection,  '(read-only)'
GreasePencil.use_stroke_endpoints -> use_stroke_endpoints:   boolean  'Only use the first and last parts of the stroke for snapping'
Group.dupli_offset -> dupli_offset:   float  'Offset from the origin to use when instancing as DupliGroup'
Group.layer -> layers:   boolean  'Layers visible when this groups is instanced as a dupli'
Group.objects -> objects:   collection,  '(read-only)    A collection of this groups objects'
Header.bl_idname -> bl_idname:   string  'NO DESCRIPTION'
Header.bl_space_type -> bl_space_type:   enum  'NO DESCRIPTION'
Header.layout -> layout:   pointer,  '(read-only)'
Histogram.mode -> mode:   enum  'Channels to display when drawing the histogram'
HookModifier.falloff -> falloff:   float  'If not zero, the distance from the hook where influence ends'
HookModifier.force -> force:   float  'Relative force of the hook'
HookModifier.object -> object:   pointer  'Parent Object for hook, also recalculates and clears offset'
HookModifier.subtarget -> subtarget:   string  'Name of Parent Bone for hook (if applicable), also recalculates and clears offset'
HookModifier.vertex_group -> vertex_group:   string  'Vertex group name'
ID.fake_user -> use_fake_user:   boolean  'Saves this datablock even if it has no users'
ID.library -> library:   pointer,  '(read-only)    Library file the datablock is linked from'
ID.name -> name:   string  'Unique datablock ID name'
ID.tag -> tag:   boolean  'Tools can use this to tag data, (initial state is undefined)'
ID.users -> users:   int,  '(read-only)    Number of times this datablock is referenced'
IDProperty.collection -> collection:   collection,  '(read-only)'
IDProperty.double -> double:   float  'NO DESCRIPTION'
IDProperty.double_array -> double_array:   float  'NO DESCRIPTION'
IDProperty.float -> float:   float  'NO DESCRIPTION'
IDProperty.float_array -> float_array:   float  'NO DESCRIPTION'
IDProperty.group -> group:   pointer,  '(read-only)'
IDProperty.int -> int:   int  'NO DESCRIPTION'
IDProperty.int_array -> int_array:   int  'NO DESCRIPTION'
IDProperty.string -> string:   string  'NO DESCRIPTION'
IDPropertyGroup.name -> name:   string  'Unique name used in the code and scripting'
IKParam.ik_solver -> ik_solver:   enum,  '(read-only)    IK solver for which these parameters are defined, 0 for Legacy, 1 for iTaSC'
Image.animated -> use_animation:   boolean  'Use as animated texture in the game engine'
Image.animation_end -> animation_end:   int  'End frame of an animated texture'
Image.animation_speed -> animation_speed:   int  'Speed of the animation in frames per second'
Image.animation_start -> animation_start:   int  'Start frame of an animated texture'
Image.bindcode -> bindcode:   int,  '(read-only)    OpenGL bindcode'
Image.clamp_x -> use_clamp_x:   boolean  'Disable texture repeating horizontally'
Image.clamp_y -> use_clamp_y:   boolean  'Disable texture repeating vertically'
Image.depth -> depth:   int,  '(read-only)    Image bit depth'
Image.dirty -> is_dirty:   boolean,  '(read-only)    Image has changed and is not saved'
Image.display_aspect -> display_aspect:   float  'Display Aspect for this image, does not affect rendering'
Image.field_order -> field_order:   enum  'Order of video fields. Select which lines are displayed first'
Image.fields -> use_fields:   boolean  'Use fields of the image'
Image.file_format -> file_format:   enum  'Format used for re-saving this file'
Image.filepath -> filepath:   string  'Image/Movie file name'
Image.filepath_raw -> filepath_raw:   string  'Image/Movie file name (without data refreshing)'
Image.generated_height -> generated_height:   int  'Generated image height'
Image.generated_type -> generated_type:   enum  'Generated image type'
Image.generated_width -> generated_width:   int  'Generated image width'
Image.has_data -> has_data:   boolean,  '(read-only)    True if this image has data'
Image.mapping -> mapping:   enum  'Mapping type to use for this image in the game engine'
Image.packed_file -> packed_file:   pointer,  '(read-only)'
Image.premultiply -> use_premultiply:   boolean  'Convert RGB from key alpha to premultiplied alpha'
Image.size -> size:   int,  '(read-only)    Width and height in pixels, zero when image data cant be loaded'
Image.source -> source:   enum  'Where the image comes from'
Image.tiles -> use_tiles:   boolean  'Use of tilemode for faces (default shift-LMB to pick the tile for selected faces)'
Image.tiles_x -> tiles_x:   int  'Degree of repetition in the X direction'
Image.tiles_y -> tiles_y:   int  'Degree of repetition in the Y direction'
Image.type -> type:   enum,  '(read-only)    How to generate the image'
ImagePaint.invert_stencil -> invert_stencil:   boolean  'Invert the stencil layer'
ImagePaint.normal_angle -> normal_angle:   int  'Paint most on faces pointing towards the view according to this angle'
ImagePaint.screen_grab_size -> screen_grab_size:   int  'Size to capture the image for re-projecting'
ImagePaint.seam_bleed -> seam_bleed:   int  'Extend paint beyond the faces UVs to reduce seams (in pixels, slower)'
ImagePaint.show_brush -> show_brush:   boolean  'Enables brush shape while not drawing'
ImagePaint.show_brush_draw -> show_brush_draw:   boolean  'Enables brush shape while drawing'
ImagePaint.use_backface_cull -> use_backface_culling:   boolean  'Ignore faces pointing away from the view (faster)'
ImagePaint.use_clone_layer -> use_clone_layer:   boolean  'Use another UV layer as clone source, otherwise use 3D the cursor as the source'
ImagePaint.use_normal_falloff -> use_normal_falloff:   boolean  'Paint most on faces pointing towards the view'
ImagePaint.use_occlude -> use_occlude:   boolean  'Only paint onto the faces directly under the brush (slower)'
ImagePaint.use_projection -> use_projection:   boolean  'Use projection painting for improved consistency in the brush strokes'
ImagePaint.use_stencil_layer -> use_stencil_layer:   boolean  'Set the mask layer from the UV layer buttons'
ImageSequence.animation_end_offset -> animation_end_offset:   int  'Animation end offset (trim end)'
ImageSequence.animation_start_offset -> animation_start_offset:   int  'Animation start offset (trim start)'
ImageSequence.color_balance -> color_balance:   pointer,  '(read-only)'
ImageSequence.color_saturation -> color_saturation:   float  'NO DESCRIPTION'
ImageSequence.convert_float -> use_float:   boolean  'Convert input to float data'
ImageSequence.crop -> crop:   pointer,  '(read-only)'
ImageSequence.de_interlace -> use_deinterlace:   boolean  'For video movies to remove fields'
ImageSequence.directory -> directory:   string  'NO DESCRIPTION'
ImageSequence.elements -> elements:   collection,  '(read-only)'
ImageSequence.flip_x -> use_flip_x:   boolean  'Flip on the X axis'
ImageSequence.flip_y -> use_flip_y:   boolean  'Flip on the Y axis'
ImageSequence.multiply_colors -> multiply_colors:   float  'NO DESCRIPTION'
ImageSequence.premultiply -> use_premultiply:   boolean  'Convert RGB from key alpha to premultiplied alpha'
ImageSequence.proxy -> proxy:   pointer,  '(read-only)'
ImageSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  'Use a custom directory to store data'
ImageSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  'Use a custom file to read proxy data from'
ImageSequence.reverse_frames -> use_reverse_frames:   boolean  'Reverse frame order'
ImageSequence.strobe -> strobe:   float  'Only display every nth frame'
ImageSequence.transform -> transform:   pointer,  '(read-only)'
ImageSequence.use_color_balance -> use_color_balance:   boolean  '(3-Way color correction) on input'
ImageSequence.use_crop -> use_crop:   boolean  'Crop image before processing'
ImageSequence.use_proxy -> use_proxy:   boolean  'Use a preview proxy for this strip'
ImageSequence.use_translation -> use_translation:   boolean  'Translate image before processing'
ImageTexture.calculate_alpha -> use_calculate_alpha:   boolean  'Calculates an alpha channel based on RGB values in the image'
ImageTexture.checker_distance -> checker_distance:   float  'Sets distance between checker tiles'
ImageTexture.checker_even -> use_checker_even:   boolean  'Sets even checker tiles'
ImageTexture.checker_odd -> use_checker_odd:   boolean  'Sets odd checker tiles'
ImageTexture.crop_max_x -> crop_max_x:   float  'Sets maximum X value to crop the image'
ImageTexture.crop_max_y -> crop_max_y:   float  'Sets maximum Y value to crop the image'
ImageTexture.crop_min_x -> crop_min_x:   float  'Sets minimum X value to crop the image'
ImageTexture.crop_min_y -> crop_min_y:   float  'Sets minimum Y value to crop the image'
ImageTexture.extension -> extension:   enum  'Sets how the image is extrapolated past its original bounds'
ImageTexture.filter -> filter:   enum  'Texture filter to use for sampling image'
ImageTexture.filter_eccentricity -> filter_eccentricity:   int  'Maximum eccentricity. Higher gives less blur at distant/oblique angles, but is also slower'
ImageTexture.filter_probes -> filter_probes:   int  'Maximum number of samples. Higher gives less blur at distant/oblique angles, but is also slower'
ImageTexture.filter_size -> filter_size:   float  'Multiplies the filter size used by MIP Map and Interpolation'
ImageTexture.filter_size_minimum -> use_minimum_filter_size:   boolean  'Use Filter Size as a minimal filter value in pixels'
ImageTexture.flip_axis -> use_flip_axis:   boolean  "Flips the texture's X and Y axis"
ImageTexture.image -> image:   pointer  'NO DESCRIPTION'
ImageTexture.image_user -> image_user:   pointer,  '(read-only)    Parameters defining which layer, pass and frame of the image is displayed'
ImageTexture.interpolation -> use_interpolation:   boolean  'Interpolates pixels using Area filter'
ImageTexture.invert_alpha -> invert_alpha:   boolean  'Inverts all the alpha values in the image'
ImageTexture.mipmap -> use_mipmap:   boolean  'Uses auto-generated MIP maps for the image'
ImageTexture.mipmap_gauss -> use_mipmap_gauss:   boolean  'Uses Gauss filter to sample down MIP maps'
ImageTexture.mirror_x -> use_mirror_x:   boolean  'Mirrors the image repetition on the X direction'
ImageTexture.mirror_y -> use_mirror_y:   boolean  'Mirrors the image repetition on the Y direction'
ImageTexture.normal_map -> use_normal_map:   boolean  'Uses image RGB values for normal mapping'
ImageTexture.normal_space -> normal_space:   enum  'Sets space of normal map image'
ImageTexture.repeat_x -> repeat_x:   int  'Sets a repetition multiplier in the X direction'
ImageTexture.repeat_y -> repeat_y:   int  'Sets a repetition multiplier in the Y direction'
ImageTexture.use_alpha -> use_alpha:   boolean  'Uses the alpha channel information in the image'
ImageUser.auto_refresh -> use_auto_refresh:   boolean  'Always refresh image on frame changes'
ImageUser.cyclic -> use_cyclic:   boolean  'Cycle the images in the movie'
ImageUser.fields_per_frame -> fields_per_frame:   int  'The number of fields per rendered frame (2 fields is 1 image)'
ImageUser.frame_start -> frame_start:   int  'Sets the global starting frame of the movie'
ImageUser.frames -> frames:   int  'Sets the number of images of a movie to use'
ImageUser.multilayer_layer -> multilayer_layer:   int,  '(read-only)    Layer in multilayer image'
ImageUser.multilayer_pass -> multilayer_pass:   int,  '(read-only)    Pass in multilayer image'
ImageUser.offset -> offset:   int  'Offsets the number of the frame to use in the animation'
InflowFluidSettings.active -> use:   boolean  'Object contributes to the fluid simulation'
InflowFluidSettings.export_animated_mesh -> use_animated_mesh:   boolean  'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'
InflowFluidSettings.inflow_velocity -> inflow_velocity:   float  'Initial velocity of fluid'
InflowFluidSettings.local_coordinates -> use_local_coordinates:   boolean  'Use local coordinates for inflow. (e.g. for rotating objects)'
InflowFluidSettings.volume_initialization -> volume_initialization:   enum  'Volume initialization type'
IntProperty.array_length -> array_length:   int,  '(read-only)    Maximum length of the array, 0 means unlimited'
IntProperty.default -> default:   int,  '(read-only)    Default value for this number'
IntProperty.default_array -> default_array:   int,  '(read-only)    Default value for this array'
IntProperty.hard_max -> hard_max:   int,  '(read-only)    Maximum value used by buttons'
IntProperty.hard_min -> hard_min:   int,  '(read-only)    Minimum value used by buttons'
IntProperty.soft_max -> soft_max:   int,  '(read-only)    Maximum value used by buttons'
IntProperty.soft_min -> soft_min:   int,  '(read-only)    Minimum value used by buttons'
IntProperty.step -> step:   int,  '(read-only)    Step size used by number buttons, for floats 1/100th of the step size'
Itasc.auto_step -> use_auto_step:   boolean  'Automatically determine the optimal number of steps for best performance/accuracy trade off'
Itasc.dampeps -> dampeps:   float  'Singular value under which damping is progressively applied. Higher values=more stability, less reactivity. Default=0.1'
Itasc.dampmax -> dampmax:   float  'Maximum damping coefficient when singular value is nearly 0. Higher values=more stability, less reactivity. Default=0.5'
Itasc.feedback -> feedback:   float  'Feedback coefficient for error correction. Average response time=1/feedback. Default=20'
Itasc.max_step -> step_max:   float  'Higher bound for timestep in second in case of automatic substeps'
Itasc.max_velocity -> velocity_max:   float  'Maximum joint velocity in rad/s. Default=50'
Itasc.min_step -> step_min:   float  'Lower bound for timestep in second in case of automatic substeps'
Itasc.mode -> mode:   enum  'NO DESCRIPTION'
Itasc.num_iter -> num_iter:   int  'Maximum number of iterations for convergence in case of reiteration'
Itasc.num_step -> num_step:   int  'Divides the frame interval into this many steps'
Itasc.precision -> precision:   float  'Precision of convergence in case of reiteration'
Itasc.reiteration -> reiteration:   enum  'Defines if the solver is allowed to reiterate (converges until precision is met) on none, first or all frames'
Itasc.solver -> solver:   enum  'Solving method selection: Automatic damping or manual damping'
JoystickSensor.all_events -> use_all_events:   boolean  'Triggered by all events on this joysticks current type (axis/button/hat)'
JoystickSensor.axis_direction -> axis_direction:   enum  'The direction of the axis'
JoystickSensor.axis_number -> axis_number:   int  'Specify which axis pair to use, 1 is usually the main direction input'
JoystickSensor.axis_threshold -> axis_threshold:   int  'Specify the precision of the axis'
JoystickSensor.button_number -> button_number:   int  'Specify which button to use'
JoystickSensor.event_type -> event_type:   enum  'The type of event this joystick sensor is triggered on'
JoystickSensor.hat_direction -> hat_direction:   enum  'Specify hat direction'
JoystickSensor.hat_number -> hat_number:   int  'Specify which hat to use'
JoystickSensor.joystick_index -> joystick_index:   int  'Specify which joystick to use'
JoystickSensor.single_axis_number -> single_axis_number:   int  'Specify a single axis (verticle/horizontal/other) to detect'
Key.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
Key.keys -> keys:   collection,  '(read-only)    Shape keys'
Key.reference_key -> reference_key:   pointer,  '(read-only)'
Key.relative -> use_relative:   boolean  'Makes shape keys relative'
Key.slurph -> slurph:   int  'Creates a delay in amount of frames in applying keypositions, first vertex goes first'
Key.user -> user:   pointer,  '(read-only)    Datablock using these shape keys'
KeyConfig.keymaps -> keymaps:   collection,  '(read-only)    Key maps configured as part of this configuration'
KeyConfig.name -> name:   string  'Name of the key configuration'
KeyConfig.user_defined -> is_user_defined:   boolean,  '(read-only)    Indicates that a keyconfig was defined by the user'
KeyMap.children_expanded -> show_expanded_children:   boolean  'Children expanded in the user interface'
KeyMap.items -> items:   collection,  '(read-only)    Items in the keymap, linking an operator to an input event'
KeyMap.items_expanded -> show_expanded_items:   boolean  'Expanded in the user interface'
KeyMap.modal -> is_modal:   boolean,  '(read-only)    Indicates that a keymap is used for translate modal events for an operator'
KeyMap.name -> name:   string,  '(read-only)    Name of the key map'
KeyMap.region_type -> region_type:   enum,  '(read-only)    Optional region type keymap is associated with'
KeyMap.space_type -> space_type:   enum,  '(read-only)    Optional space type keymap is associated with'
KeyMap.user_defined -> is_user_defined:   boolean  'Keymap is defined by the user'
KeyMapItem.active -> active:   boolean  'Activate or deactivate item'
KeyMapItem.alt -> pressed_alt:   boolean  'Alt key pressed'
KeyMapItem.any -> pressed_any:   boolean  'Any modifier keys pressed'
KeyMapItem.ctrl -> pressed_ctrl:   boolean  'Control key pressed'
KeyMapItem.expanded -> show_expanded:   boolean  'Show key map event and property details in the user interface'
KeyMapItem.id -> id:   int,  '(read-only)    ID of the item'
KeyMapItem.idname -> idname:   string  'Identifier of operator to call on input event'
KeyMapItem.key_modifier -> key_modifier:   enum  'Regular key pressed as a modifier'
KeyMapItem.map_type -> map_type:   enum  'Type of event mapping'
KeyMapItem.name -> name:   string,  '(read-only)    Name of operator to call on input event'
KeyMapItem.oskey -> pressed_cmd:   boolean  'Operating system key pressed'
KeyMapItem.properties -> properties:   pointer,  '(read-only)    Properties to set when the operator is called'
KeyMapItem.propvalue -> propvalue:   enum  'The value this event translates to in a modal keymap'
KeyMapItem.shift -> pressed_shift:   boolean  'Shift key pressed'
KeyMapItem.type -> type:   enum  'Type of event'
KeyMapItem.value -> value:   enum  'NO DESCRIPTION'
KeyboardSensor.all_keys -> use_all_keys:   boolean  'Trigger this sensor on any keystroke'
KeyboardSensor.key -> key:   enum  'NO DESCRIPTION'
KeyboardSensor.log -> log:   string  'Property that receive the keystrokes in case a string is logged'
KeyboardSensor.modifier_key -> modifier_key:   enum  'Modifier key code'
KeyboardSensor.second_modifier_key -> second_modifier_key:   enum  'Modifier key code'
KeyboardSensor.target -> target:   string  'Property that indicates whether to log keystrokes as a string'
Keyframe.co -> co:   float  'Coordinates of the control point'
Keyframe.handle1 -> handle_left:   float  'Coordinates of the first handle'
Keyframe.handle1_type -> handle_left_type:   enum  'Handle types'
Keyframe.handle2 -> handle_right:   float  'Coordinates of the second handle'
Keyframe.handle2_type -> handle_right_type:   enum  'Handle types'
Keyframe.interpolation -> interpolation:   enum  'Interpolation method to use for segment of the curve from this Keyframe until the next Keyframe'
Keyframe.select_control_point -> select_control_point:   boolean  'Control point selection status'
Keyframe.select_left_handle -> select_left_handle:   boolean  'Handle 1 selection status'
Keyframe.select_right_handle -> select_right_handle:   boolean  'Handle 2 selection status'
Keyframe.type -> type:   enum  'The type of keyframe'
KeyingSet.absolute -> use_absolute:   boolean  'Keying Set defines specific paths/settings to be keyframed (i.e. is not reliant on context info)'
KeyingSet.active_path -> active_path:   pointer  'Active Keying Set used to insert/delete keyframes'
KeyingSet.active_path_index -> active_path_index:   int  'Current Keying Set index'
KeyingSet.insertkey_needed -> use_insertkey_needed:   boolean  "Only insert keyframes where they're needed in the relevant F-Curves"
KeyingSet.insertkey_visual -> use_insertkey_visual:   boolean  "Insert keyframes based on 'visual transforms'"
KeyingSet.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:   boolean  'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'
KeyingSet.name -> name:   string  'NO DESCRIPTION'
KeyingSet.paths -> paths:   collection,  '(read-only)    Keying Set Paths to define settings that get keyframed together'
KeyingSet.type_info -> type_info:   pointer,  '(read-only)    Callback function defines for built-in Keying Sets'
KeyingSetInfo.bl_idname -> bl_idname:   string  'NO DESCRIPTION'
KeyingSetInfo.bl_label -> bl_label:   string  'NO DESCRIPTION'
KeyingSetInfo.insertkey_needed -> use_insertkey_needed:   boolean  "Only insert keyframes where they're needed in the relevant F-Curves"
KeyingSetInfo.insertkey_visual -> use_insertkey_visual:   boolean  "Insert keyframes based on 'visual transforms'"
KeyingSetInfo.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:   boolean  'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'
KeyingSetPath.array_index -> array_index:   int  'Index to the specific setting if applicable'
KeyingSetPath.data_path -> data_path:   string  'Path to property setting'
KeyingSetPath.entire_array -> use_entire_array:   boolean  "When an 'array/vector' type is chosen (Location, Rotation, Color, etc.), entire array is to be used"
KeyingSetPath.group -> group:   string  'Name of Action Group to assign setting(s) for this path to'
KeyingSetPath.grouping -> group_method:   enum  'Method used to define which Group-name to use'
KeyingSetPath.id -> id:   pointer  'ID-Block that keyframes for Keying Set should be added to (for Absolute Keying Sets only)'
KeyingSetPath.id_type -> id_type:   enum  'Type of ID-block that can be used'
KeyingSetPath.insertkey_needed -> use_insertkey_needed:   boolean  "Only insert keyframes where they're needed in the relevant F-Curves"
KeyingSetPath.insertkey_visual -> use_insertkey_visual:   boolean  "Insert keyframes based on 'visual transforms'"
KeyingSetPath.insertkey_xyz_to_rgb -> use_insertkey_xyz_to_rgb:   boolean  'Color for newly added transformation F-Curves (Location, Rotation, Scale) and also Color is based on the transform axis'
KinematicConstraint.axis_reference -> axis_reference:   enum  'Constraint axis Lock options relative to Bone or Target reference'
KinematicConstraint.chain_length -> chain_length:   int  'How many bones are included in the IK effect - 0 uses all bones'
KinematicConstraint.distance -> distance:   float  'Radius of limiting sphere'
KinematicConstraint.ik_type -> ik_type:   enum  'NO DESCRIPTION'
KinematicConstraint.iterations -> iterations:   int  'Maximum number of solving iterations'
KinematicConstraint.limit_mode -> limit_mode:   enum  'Distances in relation to sphere of influence to allow'
KinematicConstraint.orient_weight -> orient_weight:   float  'For Tree-IK: Weight of orientation control for this target'
KinematicConstraint.pole_angle -> pole_angle:   float  'Pole rotation offset'
KinematicConstraint.pole_subtarget -> pole_subtarget:   string  'NO DESCRIPTION'
KinematicConstraint.pole_target -> pole_target:   pointer  'Object for pole rotation'
KinematicConstraint.pos_lock_x -> lock_location_x:   boolean  'Constraint position along X axis'
KinematicConstraint.pos_lock_y -> lock_location_y:   boolean  'Constraint position along Y axis'
KinematicConstraint.pos_lock_z -> lock_location_z:   boolean  'Constraint position along Z axis'
KinematicConstraint.rot_lock_x -> lock_rotation_x:   boolean  'Constraint rotation along X axis'
KinematicConstraint.rot_lock_y -> lock_rotation_y:   boolean  'Constraint rotation along Y axis'
KinematicConstraint.rot_lock_z -> lock_rotation_z:   boolean  'Constraint rotation along Z axis'
KinematicConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
KinematicConstraint.target -> target:   pointer  'Target Object'
KinematicConstraint.use_position -> use_location:   boolean  'Chain follows position of target'
KinematicConstraint.use_rotation -> use_rotation:   boolean  'Chain follows rotation of target'
KinematicConstraint.use_stretch -> use_stretch:   boolean  'Enable IK Stretching'
KinematicConstraint.use_tail -> use_tail:   boolean  "Include bone's tail as last element in chain"
KinematicConstraint.use_target -> use_target:   boolean  'Disable for targetless IK'
KinematicConstraint.weight -> weight:   float  'For Tree-IK: Weight of position control for this target'
Lamp.active_texture -> active_texture:   pointer  'Active texture slot being displayed'
Lamp.active_texture_index -> active_texture_index:   int  'Index of active texture slot'
Lamp.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
Lamp.color -> color:   float  'Light color'
Lamp.diffuse -> use_diffuse:   boolean  'Lamp does diffuse shading'
Lamp.distance -> distance:   float  'Falloff distance - the light is at half the original intensity at this point'
Lamp.energy -> energy:   float  'Amount of light that the lamp emits'
Lamp.layer -> use_own_layer:   boolean  'Illuminates objects only on the same layer the lamp is on'
Lamp.negative -> use_negative:   boolean  'Lamp casts negative light'
Lamp.specular -> use_specular:   boolean  'Lamp creates specular highlights'
Lamp.texture_slots -> texture_slots:   collection,  '(read-only)    Texture slots defining the mapping and influence of textures'
Lamp.type -> type:   enum  'Type of Lamp'
LampSkySettings.atmosphere_distance_factor -> atmosphere_distance_factor:   float  'Multiplier to convert blender units to physical distance'
LampSkySettings.atmosphere_extinction -> atmosphere_extinction:   float  'Extinction scattering contribution factor'
LampSkySettings.atmosphere_inscattering -> atmosphere_inscattering:   float  'Scatter contribution factor'
LampSkySettings.atmosphere_turbidity -> atmosphere_turbidity:   float  'Sky turbidity'
LampSkySettings.backscattered_light -> backscattered_light:   float  'Backscattered light'
LampSkySettings.horizon_brightness -> horizon_intensity:   float  'Horizon brightness'
LampSkySettings.sky_blend -> sky_blend:   float  'Blend factor with sky'
LampSkySettings.sky_blend_type -> sky_blend_type:   enum  'Blend mode for combining sun sky with world sky'
LampSkySettings.sky_color_space -> sky_color_space:   enum  'Color space to use for internal XYZ->RGB color conversion'
LampSkySettings.sky_exposure -> sky_exposure:   float  'Strength of sky shading exponential exposure correction'
LampSkySettings.spread -> spread:   float  'Horizon Spread'
LampSkySettings.sun_brightness -> sun_intensity:   float  'Sun brightness'
LampSkySettings.sun_intensity -> sun_intensity:   float  'Sun intensity'
LampSkySettings.sun_size -> sun_size:   float  'Sun size'
LampSkySettings.use_atmosphere -> use_atmosphere:   boolean  'Apply sun effect on atmosphere'
LampSkySettings.use_sky -> use_sky:   boolean  'Apply sun effect on sky'
LampTextureSlot.color_factor -> color_factor:   float  'Amount texture affects color values'
LampTextureSlot.map_color -> use_map_color:   boolean  'Lets the texture affect the basic color of the lamp'
LampTextureSlot.map_shadow -> use_map_shadow:   boolean  'Lets the texture affect the shadow color of the lamp'
LampTextureSlot.object -> object:   pointer  'Object to use for mapping with Object texture coordinates'
LampTextureSlot.shadow_factor -> shadow_factor:   float  'Amount texture affects shadow'
LampTextureSlot.texture_coordinates -> texture_coordinates:   enum  'NO DESCRIPTION'
Lattice.interpolation_type_u -> interpolation_type_u:   enum  'NO DESCRIPTION'
Lattice.interpolation_type_v -> interpolation_type_v:   enum  'NO DESCRIPTION'
Lattice.interpolation_type_w -> interpolation_type_w:   enum  'NO DESCRIPTION'
Lattice.outside -> use_outside:   boolean  'Only draw, and take into account, the outer vertices'
Lattice.points -> points:   collection,  '(read-only)    Points of the lattice'
Lattice.points_u -> points_u:   int  'Points in U direction'
Lattice.points_v -> points_v:   int  'Points in V direction'
Lattice.points_w -> points_w:   int  'Points in W direction'
Lattice.shape_keys -> shape_keys:   pointer,  '(read-only)'
Lattice.vertex_group -> vertex_group:   string  'Vertex group to apply the influence of the lattice'
LatticeModifier.object -> object:   pointer  'Lattice object to deform with'
LatticeModifier.vertex_group -> vertex_group:   string  'Vertex group name'
LatticePoint.co -> co:   float,  '(read-only)'
LatticePoint.deformed_co -> deformed_co:   float  'NO DESCRIPTION'
LatticePoint.groups -> groups:   collection,  '(read-only)    Weights for the vertex groups this point is member of'
Library.filepath -> filepath:   string  'Path to the library .blend file'
Library.parent -> parent:   pointer,  '(read-only)'
LimitDistanceConstraint.distance -> distance:   float  'Radius of limiting sphere'
LimitDistanceConstraint.limit_mode -> limit_mode:   enum  'Distances in relation to sphere of influence to allow'
LimitDistanceConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
LimitDistanceConstraint.target -> target:   pointer  'Target Object'
LimitLocationConstraint.limit_transform -> limit_transform:   boolean  'Transforms are affected by this constraint as well'
LimitLocationConstraint.maximum_x -> max_x:   float  'Highest X value to allow'
LimitLocationConstraint.maximum_y -> max_y:   float  'Highest Y value to allow'
LimitLocationConstraint.maximum_z -> max_z:   float  'Highest Z value to allow'
LimitLocationConstraint.minimum_x -> min_x:   float  'Lowest X value to allow'
LimitLocationConstraint.minimum_y -> min_y:   float  'Lowest Y value to allow'
LimitLocationConstraint.minimum_z -> min_z:   float  'Lowest Z value to allow'
LimitLocationConstraint.use_maximum_x -> use_max_x:   boolean  'Use the maximum X value'
LimitLocationConstraint.use_maximum_y -> use_max_y:   boolean  'Use the maximum Y value'
LimitLocationConstraint.use_maximum_z -> use_max_z:   boolean  'Use the maximum Z value'
LimitLocationConstraint.use_minimum_x -> use_min_x:   boolean  'Use the minimum X value'
LimitLocationConstraint.use_minimum_y -> use_min_y:   boolean  'Use the minimum Y value'
LimitLocationConstraint.use_minimum_z -> use_min_z:   boolean  'Use the minimum Z value'
LimitRotationConstraint.limit_transform -> limit_transform:   boolean  'Transforms are affected by this constraint as well'
LimitRotationConstraint.maximum_x -> max_x:   float  'Highest X value to allow'
LimitRotationConstraint.maximum_y -> max_y:   float  'Highest Y value to allow'
LimitRotationConstraint.maximum_z -> max_z:   float  'Highest Z value to allow'
LimitRotationConstraint.minimum_x -> min_x:   float  'Lowest X value to allow'
LimitRotationConstraint.minimum_y -> min_y:   float  'Lowest Y value to allow'
LimitRotationConstraint.minimum_z -> min_z:   float  'Lowest Z value to allow'
LimitRotationConstraint.use_limit_x -> use_limit_x:   boolean  'Use the minimum X value'
LimitRotationConstraint.use_limit_y -> use_limit_y:   boolean  'Use the minimum Y value'
LimitRotationConstraint.use_limit_z -> use_limit_z:   boolean  'Use the minimum Z value'
LimitScaleConstraint.limit_transform -> limit_transform:   boolean  'Transforms are affected by this constraint as well'
LimitScaleConstraint.maximum_x -> max_x:   float  'Highest X value to allow'
LimitScaleConstraint.maximum_y -> max_y:   float  'Highest Y value to allow'
LimitScaleConstraint.maximum_z -> max_z:   float  'Highest Z value to allow'
LimitScaleConstraint.minimum_x -> min_x:   float  'Lowest X value to allow'
LimitScaleConstraint.minimum_y -> min_y:   float  'Lowest Y value to allow'
LimitScaleConstraint.minimum_z -> min_z:   float  'Lowest Z value to allow'
LimitScaleConstraint.use_maximum_x -> use_max_x:   boolean  'Use the maximum X value'
LimitScaleConstraint.use_maximum_y -> use_max_y:   boolean  'Use the maximum Y value'
LimitScaleConstraint.use_maximum_z -> use_max_z:   boolean  'Use the maximum Z value'
LimitScaleConstraint.use_minimum_x -> use_min_x:   boolean  'Use the minimum X value'
LimitScaleConstraint.use_minimum_y -> use_min_y:   boolean  'Use the minimum Y value'
LimitScaleConstraint.use_minimum_z -> use_min_z:   boolean  'Use the minimum Z value'
LockedTrackConstraint.lock -> lock:   enum  'Axis that points upward'
LockedTrackConstraint.subtarget -> subtarget:   string  'NO DESCRIPTION'
LockedTrackConstraint.target -> target:   pointer  'Target Object'
LockedTrackConstraint.track -> track:   enum  'Axis that points to the target object'
Macro.bl_description -> bl_description:   string  'NO DESCRIPTION'
Macro.bl_idname -> bl_idname:   string  'NO DESCRIPTION'
Macro.bl_label -> bl_label:   string  'NO DESCRIPTION'
Macro.bl_options -> bl_options:   enum  'Options for this operator type'
Macro.name -> name:   string,  '(read-only)'
Macro.properties -> properties:   pointer,  '(read-only)'
MagicTexture.noise_depth -> noise_depth:   int  'Sets the depth of the cloud calculation'
MagicTexture.turbulence -> turbulence:   float  'Sets the turbulence of the bandnoise and ringnoise types'
Main.actions -> actions:   collection,  '(read-only)    Action datablocks.'
Main.armatures -> armatures:   collection,  '(read-only)    Armature datablocks.'
Main.brushes -> brushes:   collection,  '(read-only)    Brush datablocks.'
Main.cameras -> cameras:   collection,  '(read-only)    Camera datablocks.'
Main.curves -> curves:   collection,  '(read-only)    Curve datablocks.'
Main.debug -> show_debug:   boolean  'Print debugging information in console'
Main.file_is_saved -> is_saved:   boolean,  '(read-only)    Has the current session been saved to disk as a .blend file'
Main.filepath -> filepath:   string,  '(read-only)    Path to the .blend file'
Main.fonts -> fonts:   collection,  '(read-only)    Vector font datablocks.'
Main.gpencil -> gpencil:   collection,  '(read-only)    Grease Pencil datablocks.'
Main.groups -> groups:   collection,  '(read-only)    Group datablocks.'
Main.images -> images:   collection,  '(read-only)    Image datablocks.'
Main.lamps -> lamps:   collection,  '(read-only)    Lamp datablocks.'
Main.lattices -> lattices:   collection,  '(read-only)    Lattice datablocks.'
Main.libraries -> libraries:   collection,  '(read-only)    Library datablocks.'
Main.materials -> materials:   collection,  '(read-only)    Material datablocks.'
Main.meshes -> meshes:   collection,  '(read-only)    Mesh datablocks.'
Main.metaballs -> metaballs:   collection,  '(read-only)    Metaball datablocks.'
Main.node_groups -> node_groups:   collection,  '(read-only)    Node group datablocks.'
Main.objects -> objects:   collection,  '(read-only)    Object datablocks.'
Main.particles -> particles:   collection,  '(read-only)    Particle datablocks.'
Main.scenes -> scenes:   collection,  '(read-only)    Scene datablocks.'
Main.screens -> screens:   collection,  '(read-only)    Screen datablocks.'
Main.scripts -> scripts:   collection,  '(read-only)    Script datablocks (DEPRECATED).'
Main.sounds -> sounds:   collection,  '(read-only)    Sound datablocks.'
Main.texts -> texts:   collection,  '(read-only)    Text datablocks.'
Main.textures -> textures:   collection,  '(read-only)    Texture datablocks.'
Main.window_managers -> window_managers:   collection,  '(read-only)    Window manager datablocks.'
Main.worlds -> worlds:   collection,  '(read-only)    World datablocks.'
MaintainVolumeConstraint.axis -> axis:   enum  'The free scaling axis of the object'
MaintainVolumeConstraint.volume -> volume:   float  'Volume of the bone at rest'
MarbleTexture.nabla -> nabla:   float  'Size of derivative offset used for calculating normal'
MarbleTexture.noise_basis -> noise_basis:   enum  'Sets the noise basis used for turbulence'
MarbleTexture.noise_depth -> noise_depth:   int  'Sets the depth of the cloud calculation'
MarbleTexture.noise_size -> noise_size:   float  'Sets scaling for noise input'
MarbleTexture.noise_type -> noise_type:   enum  'NO DESCRIPTION'
MarbleTexture.noisebasis2 -> noisebasis2:   enum  'NO DESCRIPTION'
MarbleTexture.stype -> stype:   enum  'NO DESCRIPTION'
MarbleTexture.turbulence -> turbulence:   float  'Sets the turbulence of the bandnoise and ringnoise types'
MaskModifier.armature -> armature:   pointer  'Armature to use as source of bones to mask'
MaskModifier.invert -> invert_vertex_group:   boolean  'Use vertices that are not part of region defined'
MaskModifier.mode -> mode:   enum  'NO DESCRIPTION'
MaskModifier.vertex_group -> vertex_group:   string  'Vertex group name'
Material.active_node_material -> active_node_material:   pointer  'Active node material'
Material.active_texture -> active_texture:   pointer  'Active texture slot being displayed'
Material.active_texture_index -> active_texture_index:   int  'Index of active texture slot'
Material.alpha -> alpha:   float  'Alpha transparency of the material'
Material.ambient -> ambient:   float  'Amount of global ambient color the material receives'
Material.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
Material.cast_approximate -> use_cast_approximate:   boolean  'Allow this material to cast shadows when using approximate ambient occlusion.'
Material.cast_buffer_shadows -> use_cast_buffer_shadows:   boolean  'Allow this material to cast shadows from shadow buffer lamps'
Material.cast_shadows_only -> use_cast_shadows_only:   boolean  'Makes objects with this material appear invisible, only casting shadows (not rendered)'
Material.cubic -> use_cubic:   boolean  'Use cubic interpolation for diffuse values, for smoother transitions'
Material.darkness -> darkness:   float  'Minnaert darkness'
Material.diffuse_color -> diffuse_color:   float  'NO DESCRIPTION'
Material.diffuse_fresnel -> diffuse_fresnel:   float  'Power of Fresnel'
Material.diffuse_fresnel_factor -> diffuse_fresnel_factor:   float  'Blending factor of Fresnel'
Material.diffuse_intensity -> diffuse_intensity:   float  'Amount of diffuse reflection'
Material.diffuse_ramp -> diffuse_ramp:   pointer,  '(read-only)    Color ramp used to affect diffuse shading'
Material.diffuse_ramp_blend -> diffuse_ramp_blend:   enum  'NO DESCRIPTION'
Material.diffuse_ramp_factor -> diffuse_ramp_factor:   float  'Blending factor (also uses alpha in Colorband)'
Material.diffuse_ramp_input -> diffuse_ramp_input:   enum  'NO DESCRIPTION'
Material.diffuse_shader -> diffuse_shader:   enum  'NO DESCRIPTION'
Material.diffuse_toon_size -> diffuse_toon_size:   float  'Size of diffuse toon area'
Material.diffuse_toon_smooth -> diffuse_toon_smooth:   float  'Smoothness of diffuse toon area'
Material.emit -> emit:   float  'Amount of light to emit'
NEGATE * Material.exclude_mist -> use_mist:   boolean  'Excludes this material from mist effects (in world settings)'
Material.face_texture -> use_face_texture:   boolean  "Replaces the object's base color with color from face assigned image textures"
Material.face_texture_alpha -> use_face_texture_alpha:   boolean  "Replaces the object's base alpha value with alpha from face assigned image textures"
Material.full_oversampling -> use_full_oversampling:   boolean  'Force this material to render full shading/textures for all anti-aliasing samples'
Material.halo -> halo:   pointer,  '(read-only)    Halo settings for the material'
Material.invert_z -> invert_z:   boolean  "Renders material's faces with an inverted Z buffer (scanline only)"
Material.light_group -> light_group:   pointer  'Limit lighting to lamps in this Group'
Material.light_group_exclusive -> use_light_group_exclusive:   boolean  'Material uses the light group exclusively - these lamps are excluded from other scene lighting'
Material.mirror_color -> mirror_color:   float  'Mirror color of the material'
Material.node_tree -> node_tree:   pointer,  '(read-only)    Node tree for node based materials'
Material.object_color -> use_object_color:   boolean  'Modulate the result with a per-object color'
Material.only_shadow -> use_only_shadow:   boolean  "Renders shadows as the material's alpha value, making materials transparent except for shadowed areas"
Material.physics -> physics:   pointer,  '(read-only)    Game physics settings'
Material.preview_render_type -> preview_render_type:   enum  'Type of preview render'
Material.ray_shadow_bias -> use_ray_shadow_bias:   boolean  'Prevents raytraced shadow errors on surfaces with smooth shaded normals (terminator problem)'
Material.raytrace_mirror -> raytrace_mirror:   pointer,  '(read-only)    Raytraced reflection settings for the material'
Material.raytrace_transparency -> raytrace_transparency:   pointer,  '(read-only)    Raytraced transparency settings for the material'
Material.receive_transparent_shadows -> use_transparent_shadows:   boolean  'Allow this object to receive transparent shadows casted through other objects'
Material.roughness -> rough:   float  'Oren-Nayar Roughness'
Material.shadeless -> use_shadeless:   boolean  'Makes this material insensitive to light or shadow'
Material.shadow_buffer_bias -> shadow_buffer_bias:   float  'Factor to multiply shadow buffer bias with (0 is ignore.)'
Material.shadow_casting_alpha -> shadow_cast_alpha:   float  'Shadow casting alpha, in use for Irregular and Deep shadow buffer'
Material.shadow_ray_bias -> shadow_ray_bias:   float  'Shadow raytracing bias to prevent terminator problems on shadow boundary'
Material.shadows -> use_shadows:   boolean  'Allows this material to receive shadows'
Material.specular_alpha -> specular_alpha:   float  'Alpha transparency for specular areas'
Material.specular_color -> specular_color:   float  'Specular color of the material'
Material.specular_hardness -> specular_hard:   int  'NO DESCRIPTION'
Material.specular_intensity -> specular_intensity:   float  'NO DESCRIPTION'
Material.specular_ior -> specular_ior:   float  'NO DESCRIPTION'
Material.specular_ramp -> specular_ramp:   pointer,  '(read-only)    Color ramp used to affect specular shading'
Material.specular_ramp_blend -> specular_ramp_blend:   enum  'NO DESCRIPTION'
Material.specular_ramp_factor -> specular_ramp_factor:   float  'Blending factor (also uses alpha in Colorband)'
Material.specular_ramp_input -> specular_ramp_input:   enum  'NO DESCRIPTION'
Material.specular_shader -> specular_shader:   enum  'NO DESCRIPTION'
Material.specular_slope -> specular_slope:   float  'The standard deviation of surface slope'
Material.specular_toon_size -> specular_toon_size:   float  'Size of specular toon area'
Material.specular_toon_smooth -> specular_toon_smooth:   float  'Smoothness of specular toon area'
Material.strand -> strand:   pointer,  '(read-only)    Strand settings for the material'
Material.subsurface_scattering -> subsurface_scattering:   pointer,  '(read-only)    Subsurface scattering settings for the material'
Material.tangent_shading -> use_tangent_shading:   boolean  "Use the material's tangent vector instead of the normal for shading - for anisotropic shading effects"
Material.texture_slots -> texture_slots:   collection,  '(read-only)    Texture slots defining the mapping and influence of textures'
Material.traceable -> use_traceable:   boolean  'Include this material and geometry that uses it in ray tracing calculations'
Material.translucency -> translucency:   float  'Amount of diffuse shading on the back side'
Material.transparency -> use_transparency:   boolean  'Render material as transparent'
Material.transparency_method -> transparency_method:   enum  'Method to use for rendering transparency'
Material.type -> type:   enum  'Material type defining how the object is rendered'
Material.use_diffuse_ramp -> use_diffuse_ramp:   boolean  'Toggle diffuse ramp operations'
Material.use_nodes -> use_nodes:   boolean  'Use shader nodes to render the material'
Material.use_sky -> use_sky:   boolean  'Renders this material with zero alpha, with sky background in place (scanline only)'
Material.use_specular_ramp -> use_specular_ramp:   boolean  'Toggle specular ramp operations'
Material.use_textures -> use_textures:   boolean  'Enable/Disable each texture'
Material.vertex_color_light -> use_vertex_color_light:   boolean  'Add vertex colors as additional lighting'
Material.vertex_color_paint -> use_vertex_color_paint:   boolean  "Replaces object base color with vertex colors (multiplies with 'texture face' face assigned textures)"
Material.volume -> volume:   pointer,  '(read-only)    Volume settings for the material'
Material.z_offset -> z_offset:   float  'Gives faces an artificial offset in the Z buffer for Z transparency'
MaterialHalo.add -> add:   float  'Sets the strength of the add effect'
MaterialHalo.flare_boost -> flare_boost:   float  'Gives the flare extra strength'
MaterialHalo.flare_mode -> use_flare_mode:   boolean  'Renders halo as a lensflare'
MaterialHalo.flare_seed -> flare_seed:   int  'Specifies an offset in the flare seed table'
MaterialHalo.flare_size -> flare_size:   float  'Sets the factor by which the flare is larger than the halo'
MaterialHalo.flare_subsize -> flare_subsize:   float  'Sets the dimension of the subflares, dots and circles'
MaterialHalo.flares_sub -> flares_sub:   int  'Sets the number of subflares'
MaterialHalo.hardness -> hard:   int  'Sets the hardness of the halo'
MaterialHalo.line_number -> line_number:   int  'Sets the number of star shaped lines rendered over the halo'
MaterialHalo.lines -> use_lines:   boolean  'Renders star shaped lines over halo'
MaterialHalo.ring -> use_ring:   boolean  'Renders rings over halo'
MaterialHalo.rings -> rings:   int  'Sets the number of rings rendered over the halo'
MaterialHalo.seed -> seed:   int  'Randomizes ring dimension and line location'
MaterialHalo.shaded -> use_shading:   boolean  'Lets halo receive light and shadows from external objects'
MaterialHalo.size -> size:   float  'Sets the dimension of the halo'
MaterialHalo.soft -> use_soft:   boolean  'Softens the edges of halos at intersections with other geometry'
MaterialHalo.star -> use_star:   boolean  'Renders halo as a star'
MaterialHalo.star_tips -> star_tips:   int  'Sets the number of points on the star shaped halo'
MaterialHalo.texture -> use_texture:   boolean  'Gives halo a texture'
MaterialHalo.vertex_normal -> use_vertex_normal:   boolean  'Uses the vertex normal to specify the dimension of the halo'
MaterialHalo.xalpha -> use_extreme_alpha:   boolean  'Uses extreme alpha'
MaterialPhysics.align_to_normal -> use_align_to_normal:   boolean  'Align dynamic game objects along the surface normal, when inside the physics distance area'
MaterialPhysics.damp -> damp:   float  'Damping of the spring force, when inside the physics distance area'
MaterialPhysics.distance -> distance:   float  'Distance of the physics area'
MaterialPhysics.elasticity -> elasticity:   float  'Elasticity of collisions'
MaterialPhysics.force -> force:   float  'Upward spring force, when inside the physics distance area'
MaterialPhysics.friction -> friction:   float  'Coulomb friction coefficient, when inside the physics distance area'
MaterialRaytraceMirror.depth -> depth:   int  'Maximum allowed number of light inter-reflections'
MaterialRaytraceMirror.distance -> distance:   float  'Maximum distance of reflected rays. Reflections further than this range fade to sky color or material color'
MaterialRaytraceMirror.enabled -> use:   boolean  'Enable raytraced reflections'
MaterialRaytraceMirror.fade_to -> fade_to:   enum  'The color that rays with no intersection within the Max Distance take. Material color can be best for indoor scenes, sky color for outdoor'
MaterialRaytraceMirror.fresnel -> fresnel:   float  'Power of Fresnel for mirror reflection'
MaterialRaytraceMirror.fresnel_factor -> fresnel_factor:   float  'Blending factor for Fresnel'
MaterialRaytraceMirror.gloss_anisotropic -> gloss_anisotropic:   float  'The shape of the reflection, from 0.0 (circular) to 1.0 (fully stretched along the tangent'
MaterialRaytraceMirror.gloss_factor -> gloss_factor:   float  'The shininess of the reflection. Values < 1.0 give diffuse, blurry reflections'
MaterialRaytraceMirror.gloss_samples -> gloss_samples:   int  'Number of cone samples averaged for blurry reflections'
MaterialRaytraceMirror.gloss_threshold -> gloss_threshold:   float  'Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped'
MaterialRaytraceMirror.reflect_factor -> reflect_factor:   float  'Sets the amount mirror reflection for raytrace'
MaterialRaytraceTransparency.depth -> depth:   int  'Maximum allowed number of light inter-refractions'
MaterialRaytraceTransparency.falloff -> falloff:   float  'Falloff power for transmissivity filter effect (1.0 is linear)'
MaterialRaytraceTransparency.filter -> filter:   float  "Amount to blend in the material's diffuse color in raytraced transparency (simulating absorption)"
MaterialRaytraceTransparency.fresnel -> fresnel:   float  'Power of Fresnel for transparency (Ray or ZTransp)'
MaterialRaytraceTransparency.fresnel_factor -> fresnel_factor:   float  'Blending factor for Fresnel'
MaterialRaytraceTransparency.gloss_factor -> gloss_factor:   float  'The clarity of the refraction. Values < 1.0 give diffuse, blurry refractions'
MaterialRaytraceTransparency.gloss_samples -> gloss_samples:   int  'Number of cone samples averaged for blurry refractions'
MaterialRaytraceTransparency.gloss_threshold -> gloss_threshold:   float  'Threshold for adaptive sampling. If a sample contributes less than this amount (as a percentage), sampling is stopped'
MaterialRaytraceTransparency.ior -> ior:   float  'Sets angular index of refraction for raytraced refraction'
MaterialRaytraceTransparency.limit -> limit:   float  'Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled)'
MaterialSlot.link -> link:   enum  "Link material to object or the object's data"
MaterialSlot.material -> material:   pointer  'Material datablock used by this material slot'
MaterialSlot.name -> name:   string,  '(read-only)    Material slot name'
MaterialStrand.blend_distance -> blend_distance:   float  'Worldspace distance over which to blend in the surface normal'
MaterialStrand.blender_units -> use_blender_units:   boolean  'Use Blender units for widths instead of pixels'
MaterialStrand.min_size -> size_min:   float  'Minimum size of strands in pixels'
MaterialStrand.root_size -> root_size:   float  'Start size of strands in pixels or Blender units'
MaterialStrand.shape -> shape:   float  'Positive values make strands rounder, negative makes strands spiky'
MaterialStrand.surface_diffuse -> use_surface_diffuse:   boolean  'Make diffuse shading more similar to shading the surface'
MaterialStrand.tangent_shading -> use_tangent_shading:   boolean  'Uses direction of strands as normal for tangent-shading'
MaterialStrand.tip_size -> tip_size:   float  'End size of strands in pixels or Blender units'
MaterialStrand.uv_layer -> uv_layer:   string  'Name of UV layer to override'
MaterialStrand.width_fade -> width_fade:   float  'Transparency along the width of the strand'
MaterialSubsurfaceScattering.back -> back:   float  'Back scattering weight'
MaterialSubsurfaceScattering.color -> color:   float  'Scattering color'
MaterialSubsurfaceScattering.color_factor -> color_factor:   float  'Blend factor for SSS colors'
MaterialSubsurfaceScattering.enabled -> use:   boolean  'Enable diffuse subsurface scatting effects in a material'
MaterialSubsurfaceScattering.error_tolerance -> error_tolerance:   float  'Error tolerance (low values are slower and higher quality)'
MaterialSubsurfaceScattering.front -> front:   float  'Front scattering weight'
MaterialSubsurfaceScattering.ior -> ior:   float  'Index of refraction (higher values are denser)'
MaterialSubsurfaceScattering.radius -> radius:   float  'Mean red/green/blue scattering path length'
MaterialSubsurfaceScattering.scale -> scale:   float  'Object scale factor'
MaterialSubsurfaceScattering.texture_factor -> texture_factor:   float  'Texture scatting blend factor'
MaterialTextureSlot.alpha_factor -> alpha_factor:   float  'Amount texture affects alpha'
MaterialTextureSlot.ambient_factor -> ambient_factor:   float  'Amount texture affects ambient'
MaterialTextureSlot.colordiff_factor -> colordiff_factor:   float  'Amount texture affects diffuse color'
MaterialTextureSlot.coloremission_factor -> coloremission_factor:   float  'Amount texture affects emission color'
MaterialTextureSlot.colorreflection_factor -> colorreflection_factor:   float  'Amount texture affects color of out-scattered light'
MaterialTextureSlot.colorspec_factor -> colorspec_factor:   float  'Amount texture affects specular color'
MaterialTextureSlot.colortransmission_factor -> colortransmission_factor:   float  'Amount texture affects result color after light has been scattered/absorbed'
MaterialTextureSlot.density_factor -> density_factor:   float  'Amount texture affects density'
MaterialTextureSlot.diffuse_factor -> diffuse_factor:   float  'Amount texture affects diffuse reflectivity'
MaterialTextureSlot.displacement_factor -> displacement_factor:   float  'Amount texture displaces the surface'
MaterialTextureSlot.emission_factor -> emission_factor:   float  'Amount texture affects emission'
MaterialTextureSlot.emit_factor -> emit_factor:   float  'Amount texture affects emission'
MaterialTextureSlot.enabled -> use:   boolean  'Enable this material texture slot'
MaterialTextureSlot.from_dupli -> use_from_dupli:   boolean  "Dupli's instanced from verts, faces or particles, inherit texture coordinate from their parent"
MaterialTextureSlot.from_original -> use_from_original:   boolean  "Dupli's derive their object coordinates from the original objects transformation"
MaterialTextureSlot.hardness_factor -> hard_factor:   float  'Amount texture affects hardness'
MaterialTextureSlot.map_alpha -> use_map_alpha:   boolean  'Causes the texture to affect the alpha value'
MaterialTextureSlot.map_ambient -> use_map_ambient:   boolean  'Causes the texture to affect the value of ambient'
MaterialTextureSlot.map_colordiff -> use_map_colordiff:   boolean  'Causes the texture to affect basic color of the material'
MaterialTextureSlot.map_coloremission -> use_map_coloremission:   boolean  'Causes the texture to affect the color of emission'
MaterialTextureSlot.map_colorreflection -> use_map_colorreflection:   boolean  'Causes the texture to affect the color of scattered light'
MaterialTextureSlot.map_colorspec -> use_map_colorspec:   boolean  'Causes the texture to affect the specularity color'
MaterialTextureSlot.map_colortransmission -> use_map_colortransmission:   boolean  'Causes the texture to affect the result color after other light has been scattered/absorbed'
MaterialTextureSlot.map_density -> use_map_density:   boolean  "Causes the texture to affect the volume's density"
MaterialTextureSlot.map_diffuse -> use_map_diffuse:   boolean  'Causes the texture to affect the value of the materials diffuse reflectivity'
MaterialTextureSlot.map_displacement -> use_map_displacement:   boolean  'Let the texture displace the surface'
MaterialTextureSlot.map_emission -> use_map_emission:   boolean  "Causes the texture to affect the volume's emission"
MaterialTextureSlot.map_emit -> use_map_emit:   boolean  'Causes the texture to affect the emit value'
MaterialTextureSlot.map_hardness -> use_map_hardness:   boolean  'Causes the texture to affect the hardness value'
MaterialTextureSlot.map_mirror -> use_map_mirror:   boolean  'Causes the texture to affect the mirror color'
MaterialTextureSlot.map_normal -> use_map_normal:   boolean  'Causes the texture to affect the rendered normal'
MaterialTextureSlot.map_raymir -> use_map_raymir:   boolean  'Causes the texture to affect the ray-mirror value'
MaterialTextureSlot.map_reflection -> use_map_reflect:   boolean  "Causes the texture to affect the reflected light's brightness"
MaterialTextureSlot.map_scattering -> use_map_scatter:   boolean  "Causes the texture to affect the volume's scattering"
MaterialTextureSlot.map_specular -> use_map_specular:   boolean  'Causes the texture to affect the value of specular reflectivity'
MaterialTextureSlot.map_translucency -> use_map_translucency:   boolean  'Causes the texture to affect the translucency value'
MaterialTextureSlot.map_warp -> use_map_warp:   boolean  'Let the texture warp texture coordinates of next channels'
MaterialTextureSlot.mapping -> mapping:   enum  'NO DESCRIPTION'
MaterialTextureSlot.mirror_factor -> mirror_factor:   float  'Amount texture affects mirror color'
MaterialTextureSlot.new_bump -> use_new_bump:   boolean  'Use new, corrected bump mapping code (backwards compatibility option)'
MaterialTextureSlot.normal_factor -> normal_factor:   float  'Amount texture affects normal values'
MaterialTextureSlot.normal_map_space -> normal_map_space:   enum  'NO DESCRIPTION'
MaterialTextureSlot.object -> object:   pointer  'Object to use for mapping with Object texture coordinates'
MaterialTextureSlot.raymir_factor -> raymir_factor:   float  'Amount texture affects ray mirror'
MaterialTextureSlot.reflection_factor -> reflection_factor:   float  'Amount texture affects brightness of out-scattered light'
MaterialTextureSlot.scattering_factor -> scattering_factor:   float  'Amount texture affects scattering'
MaterialTextureSlot.specular_factor -> specular_factor:   float  'Amount texture affects specular reflectivity'
MaterialTextureSlot.texture_coordinates -> texture_coordinates:   enum  'NO DESCRIPTION'
MaterialTextureSlot.translucency_factor -> translucency_factor:   float  'Amount texture affects translucency'
MaterialTextureSlot.uv_layer -> uv_layer:   string  'UV layer to use for mapping with UV texture coordinates'
MaterialTextureSlot.warp_factor -> warp_factor:   float  'Amount texture affects texture coordinates of next channels'
MaterialTextureSlot.x_mapping -> x_mapping:   enum  'NO DESCRIPTION'
MaterialTextureSlot.y_mapping -> y_mapping:   enum  'NO DESCRIPTION'
MaterialTextureSlot.z_mapping -> z_mapping:   enum  'NO DESCRIPTION'
MaterialVolume.asymmetry -> asymmetry:   float  'Back scattering (-1.0) to Forward scattering (1.0) and the range in between'
MaterialVolume.cache_resolution -> cache_resolution:   int  'Resolution of the voxel grid, low resolutions are faster, high resolutions use more memory'
MaterialVolume.density -> density:   float  'The base density of the volume'
MaterialVolume.density_scale -> density_scale:   float  "Multiplier for the material's density"
MaterialVolume.depth_cutoff -> depth_cutoff:   float  'Stop ray marching early if transmission drops below this luminance - higher values give speedups in dense volumes at the expense of accuracy'
MaterialVolume.emission -> emission:   float  'Amount of light that gets emitted by the volume'
MaterialVolume.emission_color -> emission_color:   float  'NO DESCRIPTION'
MaterialVolume.external_shadows -> use_external_shadows:   boolean  'Receive shadows from sources outside the volume (temporary)'
MaterialVolume.light_cache -> use_light_cache:   boolean  'Pre-calculate the shading information into a voxel grid, speeds up shading at slightly less accuracy'
MaterialVolume.lighting_mode -> light_mode:   enum  'Method of shading, attenuating, and scattering light through the volume'
MaterialVolume.ms_diffusion -> ms_diffusion:   float  'Diffusion factor, the strength of the blurring effect'
MaterialVolume.ms_intensity -> ms_intensity:   float  'Multiplier for multiple scattered light energy'
MaterialVolume.ms_spread -> ms_spread:   float  'Proportional distance over which the light is diffused'
MaterialVolume.reflection -> reflection:   float  'Multiplier to make out-scattered light brighter or darker (non-physically correct)'
MaterialVolume.reflection_color -> reflection_color:   float  'Colour of light scattered out of the volume (does not affect transmission)'
MaterialVolume.scattering -> scattering:   float  'Amount of light that gets scattered out by the volume - the more out-scattering, the shallower the light will penetrate'
MaterialVolume.step_calculation -> step_calculation:   enum  'Method of calculating the steps through the volume'
MaterialVolume.step_size -> step_size:   float  'Distance between subsequent volume depth samples'
MaterialVolume.transmission_color -> transmission_color:   float  'Result color of the volume, after other light has been scattered/absorbed'
Menu.bl_idname -> bl_idname:   string  'NO DESCRIPTION'
Menu.bl_label -> bl_label:   string  'NO DESCRIPTION'
Menu.layout -> layout:   pointer,  '(read-only)'
Mesh.active_uv_texture -> active_uv_texture:   pointer  'Active UV texture'
Mesh.active_uv_texture_index -> active_uv_texture_index:   int  'Active UV texture index'
Mesh.active_vertex_color -> active_vertex_color:   pointer  'Active vertex color layer'
Mesh.active_vertex_color_index -> active_vertex_color_index:   int  'Active vertex color index'
Mesh.all_edges -> show_all_edges:   boolean  'Displays all edges for wireframe in all view modes in the 3D view'
Mesh.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
Mesh.auto_texspace -> use_auto_texspace:   boolean  "Adjusts active object's texture space automatically when transforming object"
Mesh.autosmooth -> use_autosmooth:   boolean  "Treats all set-smoothed faces with angles less than the specified angle as 'smooth' during render"
Mesh.autosmooth_angle -> autosmooth_angle:   int  "Defines maximum angle between face normals that 'Auto Smooth' will operate on"
Mesh.double_sided -> show_double_sided:   boolean  'Render/display the mesh with double or single sided lighting'
Mesh.draw_bevel_weights -> show_bevel_weights:   boolean  'Displays weights created for the Bevel modifier'
Mesh.draw_creases -> show_creases:   boolean  'Displays creases created for subsurf weighting'
Mesh.draw_edge_angle -> show_edge_angle:   boolean  'Displays the angles in the selected edges in degrees'
Mesh.draw_edge_length -> show_edge_length:   boolean  'Displays selected edge lengths, Using global values when set in the transform panel'
Mesh.draw_edges -> show_edges:   boolean  'Displays selected edges using highlights in the 3D view and UV editor'
Mesh.draw_face_area -> show_face_area:   boolean  'Displays the area of selected faces'
Mesh.draw_faces -> show_faces:   boolean  'Displays all faces as shades in the 3D view and UV editor'
Mesh.draw_normals -> show_normals:   boolean  'Displays face normals as lines'
Mesh.draw_seams -> show_seams:   boolean  'Displays UV unwrapping seams'
Mesh.draw_sharp -> show_sharp:   boolean  'Displays sharp edges, used with the EdgeSplit modifier'
Mesh.draw_vertex_normals -> show_vertex_normals:   boolean  'Displays vertex normals as lines'
Mesh.edges -> edges:   collection,  '(read-only)    Edges of the mesh'
Mesh.faces -> faces:   collection,  '(read-only)    Faces of the mesh'
Mesh.float_layers -> float_layers:   collection,  '(read-only)'
Mesh.int_layers -> int_layers:   collection,  '(read-only)'
Mesh.materials -> materials:   collection,  '(read-only)'
Mesh.shape_keys -> shape_keys:   pointer,  '(read-only)'
Mesh.sticky -> sticky:   collection,  '(read-only)    Sticky texture coordinates'
Mesh.string_layers -> string_layers:   collection,  '(read-only)'
Mesh.texco_mesh -> texco_mesh:   pointer  'Derive texture coordinates from another mesh'
Mesh.texspace_loc -> texspace_loc:   float  'Texture space location'
Mesh.texspace_size -> texspace_size:   float  'Texture space size'
Mesh.texture_mesh -> texture_mesh:   pointer  'Use another mesh for texture indices (vertex indices must be aligned)'
Mesh.total_edge_sel -> total_edge_sel:   int,  '(read-only)    Selected edge count in editmode'
Mesh.total_face_sel -> total_face_sel:   int,  '(read-only)    Selected face count in editmode'
Mesh.total_vert_sel -> total_vert_sel:   int,  '(read-only)    Selected vertex count in editmode'
Mesh.use_mirror_topology -> use_mirror_topology:   boolean  'Use topology based mirroring'
Mesh.use_mirror_x -> use_mirror_x:   boolean  'X Axis mirror editing'
Mesh.use_paint_mask -> use_paint_mask:   boolean  'Face selection masking for painting'
Mesh.uv_texture_clone -> uv_texture_clone:   pointer  'UV texture to be used as cloning source'
Mesh.uv_texture_clone_index -> uv_texture_clone_index:   int  'Clone UV texture index'
Mesh.uv_texture_stencil -> uv_texture_stencil:   pointer  'UV texture to mask the painted area'
Mesh.uv_texture_stencil_index -> uv_texture_stencil_index:   int  'Mask UV texture index'
Mesh.uv_textures -> uv_textures:   collection,  '(read-only)'
Mesh.vertex_colors -> vertex_colors:   collection,  '(read-only)'
Mesh.verts -> verts:   collection,  '(read-only)    Vertices of the mesh'
MeshColor.color1 -> color1:   float  'NO DESCRIPTION'
MeshColor.color2 -> color2:   float  'NO DESCRIPTION'
MeshColor.color3 -> color3:   float  'NO DESCRIPTION'
MeshColor.color4 -> color4:   float  'NO DESCRIPTION'
MeshColorLayer.active -> active:   boolean  'Sets the layer as active for display and editing'
MeshColorLayer.active_render -> active_render:   boolean  'Sets the layer as active for rendering'
MeshColorLayer.data -> data:   collection,  '(read-only)'
MeshColorLayer.name -> name:   string  'NO DESCRIPTION'
MeshDeformModifier.dynamic -> use_dynamic_bind:   boolean  'Recompute binding dynamically on top of other deformers (slower and more memory consuming.)'
MeshDeformModifier.invert -> invert_vertex_group:   boolean  'Invert vertex group influence'
MeshDeformModifier.is_bound -> is_bound:   boolean,  '(read-only)    Whether geometry has been bound to control cage'
MeshDeformModifier.object -> object:   pointer  'Mesh object to deform with'
MeshDeformModifier.precision -> precision:   int  'The grid size for binding'
MeshDeformModifier.vertex_group -> vertex_group:   string  'Vertex group name'
MeshEdge.bevel_weight -> bevel_weight:   float  'Weight used by the Bevel modifier'
MeshEdge.crease -> crease:   float  'Weight used by the Subsurf modifier for creasing'
MeshEdge.fgon -> is_fgon:   boolean,  '(read-only)    Fgon edge'
MeshEdge.hide -> hide:   boolean  'NO DESCRIPTION'
MeshEdge.index -> index:   int,  '(read-only)    Index number of the vertex'
MeshEdge.loose -> is_loose:   boolean,  '(read-only)    Loose edge'
MeshEdge.seam -> use_seam:   boolean  'Seam edge for UV unwrapping'
MeshEdge.select -> select:   boolean  'NO DESCRIPTION'
MeshEdge.sharp -> use_sharp:   boolean  'Sharp edge for the EdgeSplit modifier'
MeshEdge.verts -> verts:   int  'Vertex indices'
MeshFace.area -> area:   float,  '(read-only)    read only area of the face'
MeshFace.hide -> hide:   boolean  'NO DESCRIPTION'
MeshFace.index -> index:   int,  '(read-only)    Index number of the vertex'
MeshFace.material_index -> material_index:   int  'NO DESCRIPTION'
MeshFace.normal -> normal:   float,  '(read-only)    local space unit length normal vector for this face'
MeshFace.select -> select:   boolean  'NO DESCRIPTION'
MeshFace.smooth -> use_smooth:   boolean  'NO DESCRIPTION'
MeshFace.verts -> verts:   int  'Vertex indices'
MeshFace.verts_raw -> verts_raw:   int  'Fixed size vertex indices array'
MeshFaces.active -> active:   int  'The active face for this mesh'
MeshFaces.active_tface -> active_tface:   pointer,  '(read-only)    Active Texture Face'
MeshFloatProperty.value -> value:   float  'NO DESCRIPTION'
MeshFloatPropertyLayer.data -> data:   collection,  '(read-only)'
MeshFloatPropertyLayer.name -> name:   string  'NO DESCRIPTION'
MeshIntProperty.value -> value:   int  'NO DESCRIPTION'
MeshIntPropertyLayer.data -> data:   collection,  '(read-only)'
MeshIntPropertyLayer.name -> name:   string  'NO DESCRIPTION'
MeshSticky.co -> co:   float  'Sticky texture coordinate location'
MeshStringProperty.value -> value:   string  'NO DESCRIPTION'
MeshStringPropertyLayer.data -> data:   collection,  '(read-only)'
MeshStringPropertyLayer.name -> name:   string  'NO DESCRIPTION'
MeshTextureFace.alpha_sort -> use_alpha_sort:   boolean  'Enable sorting of faces for correct alpha drawing (slow, use Clip Alpha instead when possible)'
MeshTextureFace.billboard -> use_billboard:   boolean  'Billboard with Z-axis constraint'
MeshTextureFace.collision -> use_collision:   boolean  'Use face for collision and ray-sensor detection'
MeshTextureFace.halo -> use_halo:   boolean  'Screen aligned billboard'
MeshTextureFace.image -> image:   pointer  'NO DESCRIPTION'
MeshTextureFace.invisible -> hide:   boolean  'Make face invisible'
MeshTextureFace.light -> use_light:   boolean  'Use light for face'
MeshTextureFace.object_color -> use_object_color:   boolean  'Use ObColor instead of vertex colors'
MeshTextureFace.select_uv -> select_uv:   boolean  'NO DESCRIPTION'
MeshTextureFace.shadow -> use_shadow_face:   boolean  'Face is used for shadow'
MeshTextureFace.shared -> use_blend_shared:   boolean  'Blend vertex colors across face when vertices are shared'
MeshTextureFace.tex -> use_texture:   boolean  'Render face with texture'
MeshTextureFace.text -> use_bitmap_text:   boolean  'Enable bitmap text on face'
MeshTextureFace.transp -> transp:   enum  'Transparency blending mode'
MeshTextureFace.twoside -> use_twoside:   boolean  'Render face two-sided'
MeshTextureFace.uv -> uv:   float  'NO DESCRIPTION'
MeshTextureFace.uv1 -> uv1:   float  'NO DESCRIPTION'
MeshTextureFace.uv2 -> uv2:   float  'NO DESCRIPTION'
MeshTextureFace.uv3 -> uv3:   float  'NO DESCRIPTION'
MeshTextureFace.uv4 -> uv4:   float  'NO DESCRIPTION'
MeshTextureFace.uv_pinned -> pin_uv:   boolean  'NO DESCRIPTION'
MeshTextureFace.uv_raw -> uv_raw:   float  'Fixed size UV coordinates array'
MeshTextureFaceLayer.active -> active:   boolean  'Sets the layer as active for display and editing'
MeshTextureFaceLayer.active_clone -> active_clone:   boolean  'Sets the layer as active for cloning'
MeshTextureFaceLayer.active_render -> active_render:   boolean  'Sets the layer as active for rendering'
MeshTextureFaceLayer.data -> data:   collection,  '(read-only)'
MeshTextureFaceLayer.name -> name:   string  'NO DESCRIPTION'
MeshVertex.bevel_weight -> bevel_weight:   float  "Weight used by the Bevel modifier 'Only Vertices' option"
MeshVertex.co -> co:   float  'NO DESCRIPTION'
MeshVertex.groups -> groups:   collection,  '(read-only)    Weights for the vertex groups this vertex is member of'
MeshVertex.hide -> hide:   boolean  'NO DESCRIPTION'
MeshVertex.index -> index:   int,  '(read-only)    Index number of the vertex'
MeshVertex.normal -> normal:   float  'Vertex Normal'
MeshVertex.select -> select:   boolean  'NO DESCRIPTION'
MessageActuator.body_message -> body_message:   string  'Optional message body Text'
MessageActuator.body_property -> body_property:   string  'The message body will be set by the Property Value'
MessageActuator.body_type -> body_type:   enum  'Toggle message type: either Text or a PropertyName'
MessageActuator.subject -> subject:   string  'Optional message subject. This is what can be filtered on'
MessageActuator.to_property -> to_property:   string  'Optional send message to objects with this name only, or empty to broadcast'
MessageSensor.subject -> subject:   string  'Optional subject filter: only accept messages with this subject, or empty for all'
MetaBall.active_element -> active_element:   pointer,  '(read-only)    Last selected element'
MetaBall.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
MetaBall.auto_texspace -> use_auto_texspace:   boolean  "Adjusts active object's texture space automatically when transforming object"
MetaBall.elements -> elements:   collection,  '(read-only)    Meta elements'
MetaBall.flag -> flag:   enum  'Metaball edit update behavior'
MetaBall.materials -> materials:   collection,  '(read-only)'
MetaBall.render_size -> render_size:   float  'Polygonization resolution in rendering'
MetaBall.texspace_loc -> texspace_loc:   float  'Texture space location'
MetaBall.texspace_size -> texspace_size:   float  'Texture space size'
MetaBall.threshold -> threshold:   float  'Influence of meta elements'
MetaBall.wire_size -> wire_size:   float  'Polygonization resolution in the 3D viewport'
MetaElement.hide -> hide:   boolean  'Hide element'
MetaElement.location -> location:   float  'NO DESCRIPTION'
MetaElement.negative -> use_negative:   boolean  'Set metaball as negative one'
MetaElement.radius -> radius:   float  'NO DESCRIPTION'
MetaElement.rotation -> rotation:   float  'NO DESCRIPTION'
MetaElement.size_x -> size_x:   float  'Size of element, use of components depends on element type'
MetaElement.size_y -> size_y:   float  'Size of element, use of components depends on element type'
MetaElement.size_z -> size_z:   float  'Size of element, use of components depends on element type'
MetaElement.stiffness -> stiffness:   float  'Stiffness defines how much of the element to fill'
MetaElement.type -> type:   enum  'Metaball types'
MetaSequence.animation_end_offset -> animation_end_offset:   int  'Animation end offset (trim end)'
MetaSequence.animation_start_offset -> animation_start_offset:   int  'Animation start offset (trim start)'
MetaSequence.color_balance -> color_balance:   pointer,  '(read-only)'
MetaSequence.color_saturation -> color_saturation:   float  'NO DESCRIPTION'
MetaSequence.convert_float -> use_float:   boolean  'Convert input to float data'
MetaSequence.crop -> crop:   pointer,  '(read-only)'
MetaSequence.de_interlace -> use_deinterlace:   boolean  'For video movies to remove fields'
MetaSequence.flip_x -> use_flip_x:   boolean  'Flip on the X axis'
MetaSequence.flip_y -> use_flip_y:   boolean  'Flip on the Y axis'
MetaSequence.multiply_colors -> multiply_colors:   float  'NO DESCRIPTION'
MetaSequence.premultiply -> use_premultiply:   boolean  'Convert RGB from key alpha to premultiplied alpha'
MetaSequence.proxy -> proxy:   pointer,  '(read-only)'
MetaSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  'Use a custom directory to store data'
MetaSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  'Use a custom file to read proxy data from'
MetaSequence.reverse_frames -> use_reverse_frames:   boolean  'Reverse frame order'
MetaSequence.sequences -> sequences:   collection,  '(read-only)'
MetaSequence.strobe -> strobe:   float  'Only display every nth frame'
MetaSequence.transform -> transform:   pointer,  '(read-only)'
MetaSequence.use_color_balance -> use_color_balance:   boolean  '(3-Way color correction) on input'
MetaSequence.use_crop -> use_crop:   boolean  'Crop image before processing'
MetaSequence.use_proxy -> use_proxy:   boolean  'Use a preview proxy for this strip'
MetaSequence.use_translation -> use_translation:   boolean  'Translate image before processing'
MirrorModifier.clip -> use_clip:   boolean  'Prevents vertices from going through the mirror during transform'
MirrorModifier.merge_limit -> merge_limit:   float  'Distance from axis within which mirrored vertices are merged'
MirrorModifier.mirror_object -> mirror_object:   pointer  'Object to use as mirror'
MirrorModifier.mirror_u -> use_mirror_u:   boolean  'Mirror the U texture coordinate around the 0.5 point'
MirrorModifier.mirror_v -> use_mirror_v:   boolean  'Mirror the V texture coordinate around the 0.5 point'
MirrorModifier.mirror_vertex_groups -> use_mirror_vertex_groups:   boolean  'Mirror vertex groups (e.g. .R->.L)'
MirrorModifier.x -> use_x:   boolean  'Enable X axis mirror'
MirrorModifier.y -> use_y:   boolean  'Enable Y axis mirror'
MirrorModifier.z -> use_z:   boolean  'Enable Z axis mirror'
Modifier.editmode -> show_in_editmode:   boolean  'Use modifier while in the edit mode'
Modifier.expanded -> show_expanded:   boolean  'Set modifier expanded in the user interface'
Modifier.name -> name:   string  'Modifier name'
Modifier.on_cage -> show_on_cage:   boolean  'Enable direct editing of modifier control cage'
Modifier.realtime -> show_realtime:   boolean  'Realtime display of a modifier'
Modifier.render -> use_render:   boolean  'Use modifier during rendering'
Modifier.type -> type:   enum,  '(read-only)'
MotionPath.editing -> is_edited:   boolean  'Path is being edited'
MotionPath.frame_end -> frame_end:   int,  '(read-only)    End frame of the stored range'
MotionPath.frame_start -> frame_start:   int,  '(read-only)    Starting frame of the stored range'
MotionPath.length -> length:   int,  '(read-only)    Number of frames cached'
MotionPath.points -> points:   collection,  '(read-only)    Cached positions per frame'
MotionPath.use_bone_head -> use_bone_head:   boolean,  '(read-only)    For PoseBone paths, use the bone head location when calculating this path'
MotionPathVert.co -> co:   float  'NO DESCRIPTION'
MotionPathVert.select -> select:   boolean  'Path point is selected for editing'
MouseSensor.mouse_event -> mouse_event:   enum  'Specify the type of event this mouse sensor should trigger on'
MovieSequence.animation_end_offset -> animation_end_offset:   int  'Animation end offset (trim end)'
MovieSequence.animation_start_offset -> animation_start_offset:   int  'Animation start offset (trim start)'
MovieSequence.color_balance -> color_balance:   pointer,  '(read-only)'
MovieSequence.color_saturation -> color_saturation:   float  'NO DESCRIPTION'
MovieSequence.convert_float -> use_float:   boolean  'Convert input to float data'
MovieSequence.crop -> crop:   pointer,  '(read-only)'
MovieSequence.de_interlace -> use_deinterlace:   boolean  'For video movies to remove fields'
MovieSequence.filepath -> filepath:   string  'NO DESCRIPTION'
MovieSequence.flip_x -> use_flip_x:   boolean  'Flip on the X axis'
MovieSequence.flip_y -> use_flip_y:   boolean  'Flip on the Y axis'
MovieSequence.mpeg_preseek -> mpeg_preseek:   int  'For MPEG movies, preseek this many frames'
MovieSequence.multiply_colors -> multiply_colors:   float  'NO DESCRIPTION'
MovieSequence.premultiply -> use_premultiply:   boolean  'Convert RGB from key alpha to premultiplied alpha'
MovieSequence.proxy -> proxy:   pointer,  '(read-only)'
MovieSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  'Use a custom directory to store data'
MovieSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  'Use a custom file to read proxy data from'
MovieSequence.reverse_frames -> use_reverse_frames:   boolean  'Reverse frame order'
MovieSequence.strobe -> strobe:   float  'Only display every nth frame'
MovieSequence.transform -> transform:   pointer,  '(read-only)'
MovieSequence.use_color_balance -> use_color_balance:   boolean  '(3-Way color correction) on input'
MovieSequence.use_crop -> use_crop:   boolean  'Crop image before processing'
MovieSequence.use_proxy -> use_proxy:   boolean  'Use a preview proxy for this strip'
MovieSequence.use_translation -> use_translation:   boolean  'Translate image before processing'
MulticamSequence.animation_end_offset -> animation_end_offset:   int  'Animation end offset (trim end)'
MulticamSequence.animation_start_offset -> animation_start_offset:   int  'Animation start offset (trim start)'
MulticamSequence.color_balance -> color_balance:   pointer,  '(read-only)'
MulticamSequence.color_saturation -> color_saturation:   float  'NO DESCRIPTION'
MulticamSequence.convert_float -> use_float:   boolean  'Convert input to float data'
MulticamSequence.crop -> crop:   pointer,  '(read-only)'
MulticamSequence.de_interlace -> use_deinterlace:   boolean  'For video movies to remove fields'
MulticamSequence.flip_x -> use_flip_x:   boolean  'Flip on the X axis'
MulticamSequence.flip_y -> use_flip_y:   boolean  'Flip on the Y axis'
MulticamSequence.multicam_source -> multicam_source:   int  'NO DESCRIPTION'
MulticamSequence.multiply_colors -> multiply_colors:   float  'NO DESCRIPTION'
MulticamSequence.premultiply -> use_premultiply:   boolean  'Convert RGB from key alpha to premultiplied alpha'
MulticamSequence.proxy -> proxy:   pointer,  '(read-only)'
MulticamSequence.proxy_custom_directory -> use_proxy_custom_directory:   boolean  'Use a custom directory to store data'
MulticamSequence.proxy_custom_file -> use_proxy_custom_file:   boolean  'Use a custom file to read proxy data from'
MulticamSequence.reverse_frames -> use_reverse_frames:   boolean  'Reverse frame order'
MulticamSequence.strobe -> strobe:   float  'Only display every nth frame'
MulticamSequence.transform -> transform:   pointer,  '(read-only)'
MulticamSequence.use_color_balance -> use_color_balance:   boolean  '(3-Way color correction) on input'
MulticamSequence.use_crop -> use_crop:   boolean  'Crop image before processing'
MulticamSequence.use_proxy -> use_proxy:   boolean  'Use a preview proxy for this strip'
MulticamSequence.use_translation -> use_translation:   boolean  'Translate image before processing'
MultiresModifier.external -> is_external:   boolean,  '(read-only)    Store multires displacements outside the .blend file, to save memory'
MultiresModifier.filepath -> filepath:   string  'Path to external displacements file'
MultiresModifier.levels -> levels:   int  'Number of subdivisions to use in the viewport'
MultiresModifier.optimal_display -> show_only_control_edges:   boolean  'Skip drawing/rendering of interior subdivided edges'
MultiresModifier.render_levels -> render_levels:   int  'NO DESCRIPTION'
MultiresModifier.sculpt_levels -> sculpt_levels:   int  'Number of subdivisions to use in sculpt mode'
MultiresModifier.subdivision_type -> subdivision_type:   enum  'Selects type of subdivision algorithm'
MultiresModifier.total_levels -> total_levels:   int,  '(read-only)    Number of subdivisions for which displacements are stored'
MusgraveTexture.gain -> gain:   float  'The gain multiplier'
MusgraveTexture.highest_dimension -> highest_dimension:   float  'Highest fractal dimension'
MusgraveTexture.lacunarity -> lacunarity:   float  'Gap between successive frequencies'
MusgraveTexture.musgrave_type -> musgrave_type:   enum  'NO DESCRIPTION'
MusgraveTexture.nabla -> nabla:   float  'Size of derivative offset used for calculating normal'
MusgraveTexture.noise_basis -> noise_basis:   enum  'Sets the noise basis used for turbulence'
MusgraveTexture.noise_intensity -> noise_intensity:   float  'NO DESCRIPTION'
MusgraveTexture.noise_size -> noise_size:   float  'Sets scaling for noise input'
MusgraveTexture.octaves -> octaves:   float  'Number of frequencies used'
MusgraveTexture.offset -> offset:   float  'The fractal offset'
NearSensor.distance -> distance:   float  'Trigger distance'
NearSensor.property -> property:   string  'Only look for objects with this property'
NearSensor.reset_distance -> reset_distance:   float  'NO DESCRIPTION'
NetRenderJob.name -> name:   string  'NO DESCRIPTION'
NetRenderSettings.active_blacklisted_slave_index -> active_blacklisted_slave_index:   int  'NO DESCRIPTION'
NetRenderSettings.active_job_index -> active_job_index:   int  'NO DESCRIPTION'
NetRenderSettings.active_slave_index -> active_slave_index:   int  'NO DESCRIPTION'
NetRenderSettings.chunks -> chunks:   int  'Number of frame to dispatch to each slave in one chunk'
NetRenderSettings.job_category -> job_category:   string  'Category of the job'
NetRenderSettings.job_id -> job_id:   string  'id of the last sent render job'
NetRenderSettings.job_name -> job_name:   string  'Name of the job'
NetRenderSettings.jobs -> jobs:   collection,  '(read-only)'
NetRenderSettings.master_broadcast -> use_master_broadcast:   boolean  'broadcast master server address on local network'
NetRenderSettings.master_clear -> use_master_clear:   boolean  'delete saved files on exit'
NetRenderSettings.mode -> mode:   enum  'Mode of operation of this instance'
NetRenderSettings.path -> path:   string  'Path for temporary files'
NetRenderSettings.priority -> priority:   int  'Priority of the job'
NetRenderSettings.server_address -> server_address:   string  'IP or name of the master render server'
NetRenderSettings.server_port -> server_port:   int  'port of the master render server'
NetRenderSettings.slave_clear -> use_slave_clear:   boolean  'delete downloaded files on exit'
NetRenderSettings.slave_outputlog -> use_slave_output_log:   boolean  'Output render text log to console as well as sending it to the master'
NetRenderSettings.slave_thumb -> use_slave_thumb:   boolean  'Generate thumbnails on slaves instead of master'
NetRenderSettings.slaves -> slaves:   collection,  '(read-only)'
NetRenderSettings.slaves_blacklist -> slaves_blacklist:   collection,  '(read-only)'
NetRenderSlave.name -> name:   string  'NO DESCRIPTION'
NlaStrip.action -> action:   pointer  'Action referenced by this strip'
NlaStrip.action_frame_end -> action_frame_end:   float  'NO DESCRIPTION'
NlaStrip.action_frame_start -> action_frame_start:   float  'NO DESCRIPTION'
NlaStrip.active -> active:   boolean,  '(read-only)    NLA Strip is active'
NlaStrip.animated_influence -> use_animated_influence:   boolean  'Influence setting is controlled by an F-Curve rather than automatically determined'
NlaStrip.animated_time -> use_animated_time:   boolean  'Strip time is controlled by an F-Curve rather than automatically determined'
NlaStrip.animated_time_cyclic -> use_animated_time_cyclic:   boolean  'Cycle the animated time within the action start & end'
NlaStrip.auto_blending -> use_auto_blend:   boolean  'Number of frames for Blending In/Out is automatically determined from overlapping strips'
NlaStrip.blend_in -> blend_in:   float  'Number of frames at start of strip to fade in influence'
NlaStrip.blend_out -> blend_out:   float  'NO DESCRIPTION'
NlaStrip.blending -> blend_type:   enum  "Method used for combining strip's result with accumulated result"
NlaStrip.extrapolation -> extrapolation:   enum  'Action to take for gaps past the strip extents'
NlaStrip.fcurves -> fcurves:   collection,  "(read-only)    F-Curves for controlling the strip's influence and timing"
NlaStrip.frame_end -> frame_end:   float  'NO DESCRIPTION'
NlaStrip.frame_start -> frame_start:   float  'NO DESCRIPTION'
NlaStrip.influence -> influence:   float  'Amount the strip contributes to the current result'
NlaStrip.modifiers -> modifiers:   collection,  '(read-only)    Modifiers affecting all the F-Curves in the referenced Action'
NlaStrip.mute -> mute:   boolean  'NLA Strip is not evaluated'
NlaStrip.name -> name:   string  'NO DESCRIPTION'
NlaStrip.repeat -> repeat:   float  'Number of times to repeat the action range'
NlaStrip.reversed -> use_reverse:   boolean  'NLA Strip is played back in reverse order (only when timing is automatically determined)'
NlaStrip.scale -> scale:   float  'Scaling factor for action'
NlaStrip.select -> select:   boolean  'NLA Strip is selected'
NlaStrip.strip_time -> strip_time:   float  'Frame of referenced Action to evaluate'
NlaStrip.strips -> strips:   collection,  '(read-only)    NLA Strips that this strip acts as a container for (if it is of type Meta)'
NlaStrip.type -> type:   enum,  '(read-only)    Type of NLA Strip'
NlaTrack.active -> active:   boolean,  '(read-only)    NLA Track is active'
NlaTrack.lock -> lock:   boolean  'NLA Track is locked'
NlaTrack.mute -> mute:   boolean  'NLA Track is not evaluated'
NlaTrack.name -> name:   string  'NO DESCRIPTION'
NlaTrack.select -> select:   boolean  'NLA Track is selected'
NlaTrack.solo -> is_solo:   boolean,  '(read-only)    NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled)'
NlaTrack.strips -> strips:   collection,  '(read-only)    NLA Strips on this NLA-track'
Node.inputs -> inputs:   collection,  '(read-only)'
Node.location -> location:   float  'NO DESCRIPTION'
Node.name -> name:   string  'Node name'
Node.outputs -> outputs:   collection,  '(read-only)'
NodeGroup.nodetree -> nodetree:   pointer  'NO DESCRIPTION'
NodeTree.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
NodeTree.grease_pencil -> grease_pencil:   pointer  'Grease Pencil datablock'
NodeTree.nodes -> nodes:   collection,  '(read-only)'
Object.active_material -> active_material:   pointer  'Active material being displayed'
Object.active_material_index -> active_material_index:   int  'Index of active material slot'
Object.active_particle_system -> active_particle_system:   pointer,  '(read-only)    Active particle system being displayed'
Object.active_particle_system_index -> active_particle_system_index:   int  'Index of active particle system slot'
Object.active_shape_key -> active_shape_key:   pointer,  '(read-only)    Current shape key'
Object.active_shape_key_index -> active_shape_key_index:   int  'Current shape key index'
Object.active_vertex_group -> active_vertex_group:   pointer,  '(read-only)    Vertex groups of the object'
Object.active_vertex_group_index -> active_vertex_group_index:   int  'Active index in vertex group array'
Object.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
Object.animation_visualisation -> animation_visualisation:   pointer,  '(read-only)    Animation data for this datablock'
Object.bound_box -> bound_box:   float,  '(read-only)    Objects bound box in object-space coordinates'
Object.collision -> collision:   pointer,  '(read-only)    Settings for using the objects as a collider in physics simulation'
Object.color -> color:   float  'Object color and alpha, used when faces have the ObColor mode enabled'
Object.constraints -> constraints:   collection,  '(read-only)    Constraints affecting the transformation of the object'
Object.data -> data:   pointer  'Object data'
Object.delta_location -> delta_location:   float  'Extra translation added to the location of the object'
Object.delta_rotation_euler -> delta_rotation_euler:   float  'Extra rotation added to the rotation of the object (when using Euler rotations)'
Object.delta_rotation_quaternion -> delta_rotation_quaternion:   float  'Extra rotation added to the rotation of the object (when using Quaternion rotations)'
Object.delta_scale -> delta_scale:   float  'Extra scaling added to the scale of the object'
Object.dimensions -> dimensions:   float  'Absolute bounding box dimensions of the object'
Object.draw_axis -> show_axis:   boolean  "Displays the object's origin and axis"
Object.draw_bounds -> show_bounds:   boolean  "Displays the object's bounds"
Object.draw_bounds_type -> draw_bounds_type:   enum  'Object boundary display type'
Object.draw_name -> show_name:   boolean  "Displays the object's name"
Object.draw_texture_space -> show_texture_space:   boolean  "Displays the object's texture space"
Object.draw_transparent -> show_transparent:   boolean  'Enables transparent materials for the object (Mesh only)'
Object.draw_wire -> show_wire:   boolean  "Adds the object's wireframe over solid drawing"
Object.dupli_faces_scale -> dupli_faces_scale:   float  'Scale the DupliFace objects'
Object.dupli_frames_end -> dupli_frames_end:   int  'End frame for DupliFrames'
Object.dupli_frames_off -> dupli_frames_off:   int  'Recurring frames to exclude from the Dupliframes'
Object.dupli_frames_on -> dupli_frames_on:   int  'Number of frames to use between DupOff frames'
Object.dupli_frames_start -> dupli_frames_start:   int  'Start frame for DupliFrames'
Object.dupli_group -> dupli_group:   pointer  'Instance an existing group'
Object.dupli_list -> dupli_list:   collection,  '(read-only)    Object duplis'
Object.dupli_type -> dupli_type:   enum  'If not None, object duplication method to use'
Object.duplis_used -> is_duplicator:   boolean,  '(read-only)'
Object.empty_draw_size -> empty_draw_size:   float  'Size of display for empties in the viewport'
Object.empty_draw_type -> empty_draw_type:   enum  'Viewport display style for empties'
Object.field -> field:   pointer,  '(read-only)    Settings for using the objects as a field in physics simulation'
Object.game -> game:   pointer,  '(read-only)    Game engine related settings for the object'
Object.grease_pencil -> grease_pencil:   pointer  'Grease Pencil datablock'
Object.hide -> hide:   boolean  'Restrict visibility in the viewport'
Object.hide_render -> hide_render:   boolean  'Restrict renderability'
Object.hide_select -> hide_select:   boolean  'Restrict selection in the viewport'
Object.layers -> layers:   boolean  'Layers the object is on'
Object.location -> location:   float  'Location of the object'
Object.lock_location -> lock_location:   boolean  'Lock editing of location in the interface'
Object.lock_rotation -> lock_rotation:   boolean  'Lock editing of rotation in the interface'
Object.lock_rotation_w -> lock_rotation_w:   boolean  "Lock editing of 'angle' component of four-component rotations in the interface"
Object.lock_rotations_4d -> lock_rotations_4d:   boolean  'Lock editing of four component rotations by components (instead of as Eulers)'
Object.lock_scale -> lock_scale:   boolean  'Lock editing of scale in the interface'
Object.material_slots -> material_slots:   collection,  '(read-only)    Material slots in the object'
Object.matrix_local -> matrix_local:   float  'Parent relative transformation matrix'
Object.matrix_world -> matrix_world:   float  'Worldspace transformation matrix'
Object.max_draw_type -> draw_type:   enum  'Maximum draw type to display object with in viewport'
Object.mode -> mode:   enum,  '(read-only)    Object interaction mode'
Object.modifiers -> modifiers:   collection,  '(read-only)    Modifiers affecting the geometric data of the object'
Object.motion_path -> motion_path:   pointer,  '(read-only)    Motion Path for this element'
Object.parent -> parent:   pointer  'Parent Object'
Object.parent_bone -> parent_bone:   string  'Name of parent bone in case of a bone parenting relation'
Object.parent_type -> parent_type:   enum  'Type of parent relation'
Object.parent_vertices -> parent_vertices:   int,  '(read-only)    Indices of vertices in cases of a vertex parenting relation'
Object.particle_systems -> particle_systems:   collection,  '(read-only)    Particle systems emitted from the object'
Object.pass_index -> pass_index:   int  'Index # for the IndexOB render pass'
Object.pose -> pose:   pointer,  '(read-only)    Current pose for armatures'
Object.pose_library -> pose_library:   pointer,  '(read-only)    Action used as a pose library for armatures'
Object.proxy -> proxy:   pointer,  '(read-only)    Library object this proxy object controls'
Object.proxy_group -> proxy_group:   pointer,  '(read-only)    Library group duplicator object this proxy object controls'
Object.rotation_axis_angle -> rotation_axis_angle:   float  'Angle of Rotation for Axis-Angle rotation representation'
Object.rotation_euler -> rotation_euler:   float  'Rotation in Eulers'
Object.rotation_mode -> rotation_mode:   enum  'NO DESCRIPTION'
Object.rotation_quaternion -> rotation_quaternion:   float  'Rotation in Quaternions'
Object.scale -> scale:   float  'Scaling of the object'
Object.select -> select:   boolean  'Object selection state'
Object.shape_key_edit_mode -> use_shape_key_edit_mode:   boolean  'Apply shape keys in edit mode (for Meshes only)'
Object.shape_key_lock -> show_shape_key:   boolean  'Always show the current Shape for this Object'
Object.slow_parent -> use_slow_parent:   boolean  'Create a delay in the parent relationship'
Object.soft_body -> soft_body:   pointer,  '(read-only)    Settings for soft body simulation'
Object.time_offset -> time_offset:   float  'Animation offset in frames for F-Curve and dupligroup instances'
Object.time_offset_add_parent -> use_time_offset_add_parent:   boolean  'Add the parents time offset value'
Object.time_offset_edit -> use_time_offset_edit:   boolean  'Use time offset when inserting keys and display time offset for F-Curve and action views'
Object.time_offset_parent -> use_time_offset_parent:   boolean  'Apply the time offset to this objects parent relationship'
Object.time_offset_particle -> use_time_offset_particle:   boolean  'Let the time offset work on the particle effect'
Object.track_axis -> track_axis:   enum  "Axis that points in 'forward' direction"
Object.type -> type:   enum,  '(read-only)    Type of Object'
Object.up_axis -> up_axis:   enum  'Axis that points in the upward direction'
Object.use_dupli_faces_scale -> use_dupli_faces_scale:   boolean  'Scale dupli based on face size'
Object.use_dupli_frames_speed -> use_dupli_frames_speed:   boolean  'Set dupliframes to use the frame'
Object.use_dupli_verts_rotation -> use_dupli_verts_rotation:   boolean  'Rotate dupli according to vertex normal'
Object.vertex_groups -> vertex_groups:   collection,  '(read-only)    Vertex groups of the object'
Object.x_ray -> show_x_ray:   boolean  'Makes the object draw in front of others'
ObjectActuator.add_linear_velocity -> use_add_linear_velocity:   boolean  'Toggles between ADD and SET linV'
ObjectActuator.angular_velocity -> angular_velocity:   float  'Sets the angular velocity'
ObjectActuator.damping -> damping:   int  'Number of frames to reach the target velocity'
ObjectActuator.derivate_coefficient -> derivate_coefficient:   float  'Not required, high values can cause instability'
ObjectActuator.force -> force:   float  'Sets the force'
ObjectActuator.force_max_x -> force_max_x:   float  'Set the upper limit for force'
ObjectActuator.force_max_y -> force_max_y:   float  'Set the upper limit for force'
ObjectActuator.force_max_z -> force_max_z:   float  'Set the upper limit for force'
ObjectActuator.force_min_x -> force_min_x:   float  'Set the lower limit for force'
ObjectActuator.force_min_y -> force_min_y:   float  'Set the lower limit for force'
ObjectActuator.force_min_z -> force_min_z:   float  'Set the lower limit for force'
ObjectActuator.integral_coefficient -> integral_coefficient:   float  'Low value (0.01) for slow response, high value (0.5) for fast response'
ObjectActuator.linear_velocity -> linear_velocity:   float  'Sets the linear velocity (in Servo mode it sets the target relative linear velocity, it will be achieved by automatic application of force. Null velocity is a valid target)'
ObjectActuator.loc -> loc:   float  'Sets the location'
ObjectActuator.local_angular_velocity -> use_local_angular_velocity:   boolean  'Angular velocity is defined in local coordinates'
ObjectActuator.local_force -> use_local_force:   boolean  'Force is defined in local coordinates'
ObjectActuator.local_linear_velocity -> use_local_linear_velocity:   boolean  'Velocity is defined in local coordinates'
ObjectActuator.local_location -> use_local_location:   boolean  'Location is defined in local coordinates'
ObjectActuator.local_rotation -> use_local_rotation:   boolean  'Rotation is defined in local coordinates'
ObjectActuator.local_torque -> use_local_torque:   boolean  'Torque is defined in local coordinates'
ObjectActuator.mode -> mode:   enum  'Specify the motion system'
ObjectActuator.proportional_coefficient -> proportional_coefficient:   float  'Typical value is 60x integral coefficient'
ObjectActuator.reference_object -> reference_object:   pointer  'Reference object for velocity calculation, leave empty for world reference'
ObjectActuator.rot -> rot:   float  'Sets the rotation'
ObjectActuator.servo_limit_x -> use_servo_limit_x:   boolean  'Set limit to force along the X axis'
ObjectActuator.servo_limit_y -> use_servo_limit_y:   boolean  'Set limit to force along the Y axis'
ObjectActuator.servo_limit_z -> use_servo_limit_z:   boolean  'Set limit to force along the Z axis'
ObjectActuator.torque -> torque:   float  'Sets the torque'
ObjectBase.layers -> layers:   boolean  'Layers the object base is on'
ObjectBase.object -> object:   pointer,  '(read-only)    Object this base links to'
ObjectBase.select -> select:   boolean  'Object base selection state'
ObjectConstraints.active -> active:   pointer  'Active Object constraint'
ObstacleFluidSettings.active -> use:   boolean  'Object contributes to the fluid simulation'
ObstacleFluidSettings.export_animated_mesh -> use_animated_mesh:   boolean  'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'
ObstacleFluidSettings.impact_factor -> impact_factor:   float  'This is an unphysical value for moving objects - it controls the impact an obstacle has on the fluid, =0 behaves a bit like outflow (deleting fluid), =1 is default, while >1 results in high forces. Can be used to tweak total mass'
ObstacleFluidSettings.partial_slip_factor -> partial_slip_factor:   float  'Amount of mixing between no- and free-slip, 0 is no slip and 1 is free slip'
ObstacleFluidSettings.slip_type -> slip_type:   enum  'NO DESCRIPTION'
ObstacleFluidSettings.volume_initialization -> volume_initialization:   enum  'Volume initialization type'
Operator.bl_description -> bl_description:   string  'NO DESCRIPTION'
Operator.bl_idname -> bl_idname:   string  'NO DESCRIPTION'
Operator.bl_label -> bl_label:   string  'NO DESCRIPTION'
Operator.bl_options -> bl_options:   enum  'Options for this operator type'
Operator.has_reports -> has_reports:   boolean,  '(read-only)    Operator has a set of reports (warnings and errors) from last execution'
Operator.layout -> layout:   pointer,  '(read-only)'
Operator.name -> name:   string,  '(read-only)'
Operator.properties -> properties:   pointer,  '(read-only)'
OperatorFileListElement.name -> name:   string  'the name of a file or directory within a file list'
OperatorMousePath.loc -> loc:   float  'Mouse location'
OperatorMousePath.time -> time:   float  'Time of mouse location'
OperatorStrokeElement.location -> location:   float  'NO DESCRIPTION'
OperatorStrokeElement.mouse -> mouse:   float  'NO DESCRIPTION'
OperatorStrokeElement.pen_flip -> pen_flip:   boolean  'NO DESCRIPTION'
OperatorStrokeElement.pressure -> pressure:   float  'Tablet pressure'
OperatorStrokeElement.time -> time:   float  'NO DESCRIPTION'
OperatorTypeMacro.properties -> properties:   pointer,  '(read-only)'
OutflowFluidSettings.active -> use:   boolean  'Object contributes to the fluid simulation'
OutflowFluidSettings.export_animated_mesh -> use_animated_mesh:   boolean  'Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it'
OutflowFluidSettings.volume_initialization -> volume_initialization:   enum  'Volume initialization type'
PackedFile.size -> size:   int,  '(read-only)    Size of packed file in bytes'
Paint.brush -> brush:   pointer  'Active paint brush'
Paint.fast_navigate -> show_low_resolution:   boolean  'For multires, show low resolution while navigating the view'
Paint.show_brush -> show_brush:   boolean  'NO DESCRIPTION'
Paint.show_brush_on_surface -> show_brush_on_surface:   boolean  'NO DESCRIPTION'
Panel.bl_context -> bl_context:   string  'NO DESCRIPTION'
Panel.bl_default_closed -> bl_use_closed:   boolean  'NO DESCRIPTION'
Panel.bl_idname -> bl_idname:   string  'NO DESCRIPTION'
Panel.bl_label -> bl_label:   string  'NO DESCRIPTION'
Panel.bl_region_type -> bl_region_type:   enum  'NO DESCRIPTION'
Panel.bl_show_header -> bl_show_header:   boolean  'NO DESCRIPTION'
Panel.bl_space_type -> bl_space_type:   enum  'NO DESCRIPTION'
Panel.layout -> layout:   pointer,  '(read-only)'
Panel.text -> text:   string  'NO DESCRIPTION'
ParentActuator.compound -> use_compound:   boolean  'Add this object shape to the parent shape (only if the parent shape is already compound)'
ParentActuator.ghost -> use_ghost:   boolean  'Make this object ghost while parented (only if not compound)'
ParentActuator.mode -> mode:   enum  'NO DESCRIPTION'
ParentActuator.object -> object:   pointer  'Set this object as parent'
Particle.alive_state -> alive_state:   enum  'NO DESCRIPTION'
Particle.angular_velocity -> angular_velocity:   float  'NO DESCRIPTION'
Particle.birthtime -> birthtime:   float  'NO DESCRIPTION'
Particle.die_time -> die_time:   float  'NO DESCRIPTION'
Particle.hair -> hair:   collection,  '(read-only)'
Particle.is_existing -> is_existing:   boolean,  '(read-only)'
Particle.is_visible -> is_visible:   boolean,  '(read-only)'
Particle.keys -> keys:   collection,  '(read-only)'
Particle.lifetime -> lifetime:   float  'NO DESCRIPTION'
Particle.location -> location:   float  'NO DESCRIPTION'
Particle.prev_angular_velocity -> prev_angular_velocity:   float  'NO DESCRIPTION'
Particle.prev_location -> prev_location:   float  'NO DESCRIPTION'
Particle.prev_rotation -> prev_rotation:   float  'NO DESCRIPTION'
Particle.prev_velocity -> prev_velocity:   float  'NO DESCRIPTION'
Particle.rotation -> rotation:   float  'NO DESCRIPTION'
Particle.size -> size:   float  'NO DESCRIPTION'
Particle.velocity -> velocity:   float  'NO DESCRIPTION'
ParticleBrush.count -> count:   int  'Particle count'
ParticleBrush.curve -> curve:   pointer,  '(read-only)'
ParticleBrush.length_mode -> length_mode:   enum  'NO DESCRIPTION'
ParticleBrush.puff_mode -> puff_mode:   enum  'NO DESCRIPTION'
ParticleBrush.size -> size:   int  'Brush size'
ParticleBrush.steps -> steps:   int  'Brush steps'
ParticleBrush.strength -> strength:   float  'Brush strength'
ParticleBrush.use_puff_volume -> use_puff_volume:   boolean  'Apply puff to unselected end-points, (helps maintain hair volume when puffing root)'
ParticleDupliWeight.count -> count:   int  'The number of times this object is repeated with respect to other objects'
ParticleDupliWeight.name -> name:   string,  '(read-only)    Particle dupliobject name'
ParticleEdit.add_interpolate -> use_add_interpolate:   boolean  'Interpolate new particles from the existing ones'
ParticleEdit.add_keys -> add_keys:   int  'How many keys to make new particles with'
ParticleEdit.auto_velocity -> use_auto_velocity:   boolean  'Calculate point velocities automatically'
ParticleEdit.brush -> brush:   pointer,  '(read-only)'
ParticleEdit.draw_particles -> show_particles:   boolean  'Draw actual particles'
ParticleEdit.draw_step -> draw_step:   int  'How many steps to draw the path with'
ParticleEdit.editable -> is_editable:   boolean,  '(read-only)    A valid edit mode exists'
ParticleEdit.emitter_deflect -> use_emitter_deflect:   boolean  'Keep paths from intersecting the emitter'
ParticleEdit.emitter_distance -> emitter_distance:   float  'Distance to keep particles away from the emitter'
ParticleEdit.fade_frames -> fade_frames:   int  'How many frames to fade'
ParticleEdit.fade_time -> use_fade_time:   boolean  'Fade paths and keys further away from current frame'
ParticleEdit.hair -> is_hair:   boolean,  '(read-only)    Editing hair'
ParticleEdit.keep_lengths -> use_preserve_lengths:   boolean  'Keep path lengths constant'
ParticleEdit.keep_root -> use_preserve_root:   boolean  'Keep root keys unmodified'
ParticleEdit.object -> object:   pointer,  '(read-only)    The edited object'
ParticleEdit.selection_mode -> selection_mode:   enum  'Particle select and display mode'
ParticleEdit.tool -> tool:   enum  'NO DESCRIPTION'
ParticleEdit.type -> type:   enum  'NO DESCRIPTION'
ParticleFluidSettings.alpha_influence -> alpha_influence:   float  'Amount of particle alpha change, inverse of size influence: 0=off (all same alpha), 1=full. (large particles get lower alphas, smaller ones higher values)'
ParticleFluidSettings.drops -> use_drops:   boolean  'Show drop particles'
ParticleFluidSettings.floats -> use_floats:   boolean  'Show floating foam particles'
ParticleFluidSettings.particle_influence -> particle_influence:   float  'Amount of particle size scaling: 0=off (all same size), 1=full (range 0.2-2.0), >1=stronger'
ParticleFluidSettings.path -> path:   string  'Directory (and/or filename prefix) to store and load particles from'
ParticleFluidSettings.tracer -> use_tracer:   boolean  'Show tracer particles'
ParticleHairKey.location -> location:   float  'Location of the hair key in object space'
ParticleHairKey.location_hairspace -> location_hairspace:   float  'Location of the hair key in its internal coordinate system, relative to the emitting face'
ParticleHairKey.time -> time:   float  'Relative time of key over hair length'
ParticleHairKey.weight -> weight:   float  'Weight for cloth simulation'
ParticleInstanceModifier.alive -> use_alive:   boolean  'Show instances when particles are alive'
ParticleInstanceModifier.axis -> axis:   enum  'Pole axis for rotation'
ParticleInstanceModifier.children -> use_children:   boolean  'Create instances from child particles'
ParticleInstanceModifier.dead -> use_dead:   boolean  'Show instances when particles are dead'
ParticleInstanceModifier.keep_shape -> use_preserve_shape:   boolean  "Don't stretch the object"
ParticleInstanceModifier.normal -> use_normal:   boolean  'Create instances from normal particles'
ParticleInstanceModifier.object -> object:   pointer  'Object that has the particle system'
ParticleInstanceModifier.particle_system_number -> particle_system_number:   int  'NO DESCRIPTION'
ParticleInstanceModifier.position -> position:   float  'Position along path'
ParticleInstanceModifier.random_position -> random_position:   float  'Randomize position along path'
ParticleInstanceModifier.size -> use_size:   boolean  'Use particle size to scale the instances'
ParticleInstanceModifier.unborn -> use_unborn:   boolean  'Show instances when particles are unborn'
ParticleInstanceModifier.use_path -> use_path:   boolean  'Create instances along particle paths'
ParticleKey.angular_velocity -> angular_velocity:   float  'Key angular velocity'
ParticleKey.location -> location:   float  'Key location'
ParticleKey.rotation -> rotation:   float  'Key rotation quaterion'
ParticleKey.time -> time:   float  'Time of key over the simulation'
ParticleKey.velocity -> velocity:   float  'Key velocity'
ParticleSettings.abs_path_time -> use_absolute_path_time:   boolean  'Path timing is in absolute frames'
ParticleSettings.active_dupliweight -> active_dupliweight:   pointer,  '(read-only)'
ParticleSettings.active_dupliweight_index -> active_dupliweight_index:   int  'NO DESCRIPTION'
ParticleSettings.adaptive_angle -> adaptive_angle:   int  'How many degrees path has to curve to make another render segment'
ParticleSettings.adaptive_pix -> adaptive_pix:   int  'How many pixels path has to cover to make another render segment'
ParticleSettings.amount -> amount:   int  'Total number of particles'
ParticleSettings.angular_velocity_factor -> angular_velocity_factor:   float  'Angular velocity amount'
ParticleSettings.angular_velocity_mode -> angular_velocity_mode:   enum  'Particle angular velocity mode'
ParticleSettings.animate_branching -> use_animate_branching:   boolean  'Animate branching'
ParticleSettings.animation_data -> animation_data:   pointer,  '(read-only)    Animation data for this datablock'
ParticleSettings.billboard_align -> billboard_align:   enum  'In respect to what the billboards are aligned'
ParticleSettings.billboard_animation -> billboard_animation:   enum  'How to animate billboard textures'
ParticleSettings.billboard_lock -> lock_billboard:   boolean  'Lock the billboards align axis'
ParticleSettings.billboard_object -> billboard_object:   pointer  'Billboards face this object (default is active camera)'
ParticleSettings.billboard_offset -> billboard_offset:   float  'NO DESCRIPTION'
ParticleSettings.billboard_random_tilt -> billboard_random_tilt:   float  'Random tilt of the billboards'
ParticleSettings.billboard_split_offset -> billboard_split_offset:   enum  'How to offset billboard textures'
ParticleSettings.billboard_tilt -> billboard_tilt:   float  'Tilt of the billboards'
ParticleSettings.billboard_uv_split -> billboard_uv_split:   int  'Amount of rows/columns to split UV coordinates for billboards'
ParticleSettings.boids -> boids:   pointer,  '(read-only)'
ParticleSettings.boids_2d -> lock_boids_to_surface:   boolean  'Constrain boids to a surface'
ParticleSettings.branch_threshold -> branch_threshold:   float  'Threshold of branching'
ParticleSettings.branching -> use_branching:   boolean  'Branch child paths from each other'
ParticleSettings.brownian_factor -> brownian_factor:   float  'Specify the amount of Brownian motion'
ParticleSettings.child_effector -> apply_effector_to_children:   boolean  'Apply effectors to children'
ParticleSettings.child_guide -> apply_guide_to_children:   boolean  'NO DESCRIPTION'
ParticleSettings.child_length -> child_length:   float  'Length of child paths'
ParticleSettings.child_length_thres -> child_length_thres:   float  'Amount of particles left untouched by child path length'
ParticleSettings.child_nbr -> child_nbr:   int  'Amount of children/parent'
ParticleSettings.child_radius -> child_radius:   float  'Radius of children around parent'
ParticleSettings.child_random_size -> child_random_size:   float  'Random variation to the size of the child particles'
ParticleSettings.child_roundness -> child_roundness:   float  'Roundness of children around parent'
ParticleSettings.child_size -> child_size:   float  'A multiplier for the child particle size'
ParticleSettings.child_type -> child_type:   enum  'Create child particles'
ParticleSettings.clump_factor -> clump_factor:   float  'Amount of clumping'
ParticleSettings.clumppow -> clumppow:   float  'Shape of clumping'
ParticleSettings.damp_factor -> damp_factor:   float  'Specify the amount of damping'
ParticleSettings.die_on_collision -> use_die_on_collision:   boolean  'Particles die when they collide with a deflector object'
ParticleSettings.died -> use_died:   boolean  'Show particles after they have died'
ParticleSettings.display -> display:   int  'Percentage of particles to display in 3D view'
ParticleSettings.distribution -> distribution:   enum  'How to distribute particles on selected element'
ParticleSettings.drag_factor -> drag_factor:   float  'Specify the amount of air-drag'
ParticleSettings.draw_as -> draw_as:   enum  'How particles are drawn in viewport'
ParticleSettings.draw_health -> show_health:   boolean  'Draw boid health'
ParticleSettings.draw_size -> draw_size:   int  'Size of particles on viewport in pixels (0=default)'
ParticleSettings.draw_step -> draw_step:   int  'How many steps paths are drawn with (power of 2)'
ParticleSettings.dupli_group -> dupli_group:   pointer  'Show Objects in this Group in place of particles'
ParticleSettings.dupli_object -> dupli_object:   pointer  'Show this Object in place of particles'
ParticleSettings.dupliweights -> dupliweights:   collection,  '(read-only)    Weights for all of the objects in the dupli group'
ParticleSettings.effect_hair -> effect_hair:   float  'Hair stiffness for effectors'
ParticleSettings.effector_weights -> effector_weights:   pointer,  '(read-only)'
ParticleSettings.emit_from -> emit_from:   enum  'Where to emit particles from'
ParticleSettings.emitter -> use_render_emitter:   boolean  'Render emitter Object also'
ParticleSettings.enable_simplify -> use_simplify:   boolean  'Remove child strands as the object becomes smaller on the screen'
ParticleSettings.even_distribution -> use_even_distribution:   boolean  'Use even distribution from faces based on face areas or edge lengths'
ParticleSettings.fluid -> fluid:   pointer,  '(read-only)'
ParticleSettings.force_field_1 -> force_field_1:   pointer,  '(read-only)'
ParticleSettings.force_field_2 -> force_field_2:   pointer,  '(read-only)'
ParticleSettings.frame_end -> frame_end:   float  'Frame # to stop emitting particles'
ParticleSettings.frame_start -> frame_start:   float  'Frame # to start emitting particles'
ParticleSettings.grid_invert -> invert_grid:   boolean  'Invert what is considered object and what is not'
ParticleSettings.grid_resolution -> grid_resolution:   int  'The resolution of the particle grid'
ParticleSettings.hair_bspline -> use_hair_bspline:   boolean  'Interpolate hair using B-Splines'
ParticleSettings.hair_step -> hair_step:   int  'Number of hair segments'
ParticleSettings.integrator -> integrator:   enum  'Select physics integrator type'
ParticleSettings.jitter_factor -> jitter_factor:   float  'Amount of jitter applied to the sampling'
ParticleSettings.keyed_loops -> keyed_loops:   int  'Number of times the keys are looped'
ParticleSettings.keys_step -> keys_step:   int  'NO DESCRIPTION'
ParticleSettings.kink -> kink:   enum  'Type of periodic offset on the path'
ParticleSettings.kink_amplitude -> kink_amplitude:   float  'The amplitude of the offset'
ParticleSettings.kink_axis -> kink_axis:   enum  'Which axis to use for offset'
ParticleSettings.kink_frequency -> kink_frequency:   float  'The frequency of the offset (1/total length)'
ParticleSettings.kink_shape -> kink_shape:   float  'Adjust the offset to the beginning/end'
ParticleSettings.lifetime -> lifetime:   float  'Specify the life span of the particles'
ParticleSettings.line_length_head -> line_length_head:   float  "Length of the line's head"
ParticleSettings.line_length_tail -> line_length_tail:   float  "Length of the line's tail"
ParticleSettings.mass -> mass:   float  'Specify the mass of the particles'
ParticleSettings.material -> material:   int  'Specify material used for the particles'
ParticleSettings.material_color -> show_material_color:   boolean  "Draw particles using material's diffuse color"
ParticleSettings.normal_factor -> normal_factor:   float  'Let the surface normal give the particle a starting speed'
ParticleSettings.num -> show_number:   boolean  'Show particle number'
ParticleSettings.object_aligned_factor -> object_aligned_factor:   float  'Let the emitter object orientation give the particle a starting speed'
ParticleSettings.object_factor -> object_factor:   float  'Let the object give the particle a starting speed'
ParticleSettings.parent -> use_parents:   boolean  'Render parent particles'
ParticleSettings.particle_factor -> particle_factor:   float  'Let the target particle give the particle a starting speed'
ParticleSettings.particle_size -> particle_size:   float  'The size of the particles'
ParticleSettings.path_end -> path_end:   float  'End time of drawn path'
ParticleSettings.path_start -> path_start:   float  'Starting time of drawn path'
ParticleSettings.phase_factor -> phase_factor:   float  'Initial rotation phase'
ParticleSettings.physics_type -> physics_type:   enum  'Particle physics type'
ParticleSettings.rand_group -> use_group_pick_random:   boolean  'Pick objects from group randomly'
ParticleSettings.random_factor -> random_factor:   float  'Give the starting speed a random variation'
ParticleSettings.random_length -> random_length:   float  'Give path length a random variation'
ParticleSettings.random_lifetime -> random_lifetime:   float  'Give the particle life a random variation'
ParticleSettings.random_phase_factor -> random_phase_factor:   float  'Randomize rotation phase'
ParticleSettings.random_rotation_factor -> random_rotation_factor:   float  'Randomize rotation'
ParticleSettings.random_size -> random_size:   float  'Give the particle size a random variation'
ParticleSettings.react_event -> react_event:   enum  'The event of target particles to react on'
ParticleSettings.react_multiple -> use_react_multiple:   boolean  'React multiple times'
ParticleSettings.react_start_end -> use_react_start_end:   boolean  'Give birth to unreacted particles eventually'
ParticleSettings.reaction_shape -> reaction_shape:   float  'Power of reaction strength dependence on distance to target'
ParticleSettings.reactor_factor -> reactor_factor:   float  'Let the vector away from the target particles location give the particle a starting speed'
ParticleSettings.ren_as -> ren_as:   enum  'How particles are rendered'
ParticleSettings.render_adaptive -> use_render_adaptive:   boolean  'Use adapative rendering for paths'
ParticleSettings.render_step -> render_step:   int  'How many steps paths are rendered with (power of 2)'
ParticleSettings.render_strand -> use_strand_primitive:   boolean  'Use the strand primitive for rendering'
ParticleSettings.rendered_child_nbr -> rendered_child_nbr:   int  'Amount of children/parent for rendering'
ParticleSettings.rotate_from -> rotate_from:   enum  'NO DESCRIPTION'
ParticleSettings.rotation_dynamic -> use_dynamic_rotation:   boolean  'Sets rotation to dynamic/constant'
ParticleSettings.rotation_mode -> rotation_mode:   enum  'Particles initial rotation'
ParticleSettings.rough1 -> rough1:   float  'Amount of location dependent rough'
ParticleSettings.rough1_size -> rough1_size:   float  'Size of location dependent rough'
ParticleSettings.rough2 -> rough2:   float  'Amount of random rough'
ParticleSettings.rough2_size -> rough2_size:   float  'Size of random rough'
ParticleSettings.rough2_thres -> rough2_thres:   float  'Amount of particles left untouched by random rough'
ParticleSettings.rough_end_shape -> rough_end_shape:   float  'Shape of end point rough'
ParticleSettings.rough_endpoint -> rough_endpoint:   float  'Amount of end point rough'
ParticleSettings.self_effect -> use_self_effect:   boolean  'Particle effectors effect themselves'
ParticleSettings.show_size -> show_size:   boolean  'Show particle size'
ParticleSettings.simplify_rate -> simplify_rate:   float  'Speed of simplification'
ParticleSettings.simplify_refsize -> simplify_refsize:   int  'Reference size in pixels, after which simplification begins'
ParticleSettings.simplify_transition -> simplify_transition:   float  'Transition period for fading out strands'
ParticleSettings.simplify_viewport -> simplify_viewport:   float  'Speed of Simplification'
ParticleSettings.size_deflect -> use_size_deflect:   boolean  "Use particle's size in deflection"
ParticleSettings.sizemass -> use_multiply_size_mass:   boolean  'Multiply mass by particle size'
ParticleSettings.subframes -> subframes:   int  'Subframes to simulate for improved stability and finer granularity simulations'
ParticleSettings.symmetric_branching -> use_symmetric_branching:   boolean  'Start and end points are the same'
ParticleSettings.tangent_factor -> tangent_factor:   float  'Let the surface tangent give the particle a starting speed'
ParticleSettings.tangent_phase -> tangent_phase:   float  'Rotate the surface tangent'
ParticleSettings.time_tweak -> time_tweak:   float  'A multiplier for physics timestep (1.0 means one frame = 1/25 seconds)'
ParticleSettings.trail_count -> trail_count:   int  'Number of trail particles'
ParticleSettings.trand -> use_emit_random:   boolean  'Emit in random order of elements'
ParticleSettings.type -> type:   enum  'NO DESCRIPTION'
ParticleSettings.unborn -> use_unborn:   boolean  'Show particles before they are emitted'
ParticleSettings.use_global_dupli -> use_global_dupli:   boolean  "Use object's global coordinates for duplication"
ParticleSettings.use_group_count -> use_group_count:   boolean  'Use object multiple times in the same group'
ParticleSettings.userjit -> userjit:   int  'Emission locations / face (0 = automatic)'
ParticleSettings.velocity -> show_velocity:   boolean  'Show particle velocity'
ParticleSettings.velocity_length -> use_velocity_length:   boolean  'Multiply line length by particle speed'
ParticleSettings.viewport -> use_simplify_viewport:   boolean  'NO DESCRIPTION'
ParticleSettings.virtual_parents -> virtual_parents:   float  'Relative amount of virtual parents'
ParticleSettings.whole_group -> use_whole_group:   boolean  'Use whole group at once'
ParticleSystem.active_particle_target -> active_particle_target:   pointer,  '(read-only)'
ParticleSystem.active_particle_target_index -> active_particle_target_index:   int  'NO DESCRIPTION'
ParticleSystem.billboard_normal_uv -> billboard_normal_uv:   string  'UV Layer to control billboard normals'
ParticleSystem.billboard_split_uv -> billboard_split_uv:   string  'UV Layer to control billboard splitting'
ParticleSystem.billboard_time_index_uv -> billboard_time_index_uv:   string  'UV Layer to control billboard time index (X-Y)'
ParticleSystem.child_particles -> child_particles:   collection,  '(read-only)    Child particles generated by the particle system'
ParticleSystem.cloth -> cloth:   pointer,  '(read-only)    Cloth dynamics for hair'
ParticleSystem.editable -> is_editable:   boolean,  '(read-only)    Particle system can be edited in particle mode'
ParticleSystem.edited -> is_edited:   boolean,  '(read-only)    Particle system has been edited in particle mode'
ParticleSystem.global_hair -> is_global_hair:   boolean,  '(read-only)    Hair keys are in global coordinate space'
ParticleSystem.hair_dynamics -> use_hair_dynamics:   boolean  'Enable hair dynamics using cloth simulation'
ParticleSystem.keyed_timing -> use_keyed_timing:   boolean  'Use key times'
ParticleSystem.multiple_caches -> has_multiple_caches:   boolean,  '(read-only)    Particle system has multiple point caches'
ParticleSystem.name -> name:   string  'Particle system name'
ParticleSystem.parent -> parent:   pointer  "Use this object's coordinate system instead of global coordinate system"
ParticleSystem.particles -> particles:   collection,  '(read-only)    Particles generated by the particle system'
ParticleSystem.point_cache -> point_cache:   pointer,  '(read-only)'
ParticleSystem.reactor_target_object -> reactor_target_object:   pointer  'For reactor systems, the object that has the target particle system (empty if same object)'
ParticleSystem.reactor_target_particle_system -> reactor_target_particle_system:   int  'For reactor systems, index of particle system on the target object'
ParticleSystem.seed -> seed:   int  'Offset in the random number table, to get a different randomized result'
ParticleSystem.settings -> settings:   pointer  'Particle system settings'
ParticleSystem.targets -> targets:   collection,  '(read-only)    Target particle systems'
ParticleSystem.vertex_group_clump -> vertex_group_clump:   string  'Vertex group to control clump'
ParticleSystem.vertex_group_clump_negate -> invert_vertex_group_clump:   boolean  'Negate the effect of the clump vertex group'
ParticleSystem.vertex_group_density -> vertex_group_density:   string  'Vertex group to control density'
ParticleSystem.vertex_group_density_negate -> invert_vertex_group_density:   boolean  'Negate the effect of the density vertex group'